<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head><link rel="stylesheet" type="text/css" href="style.css" /><script type="text/javascript" src="highlight.js"></script></head><body><pre><span class="hs-pragma">{-# LANGUAGE CPP #-}</span><span>
</span><span id="line-2"></span><span class="hs-pragma">{-# LANGUAGE DataKinds #-}</span><span>
</span><span id="line-3"></span><span class="hs-pragma">{-# LANGUAGE PolyKinds #-}</span><span>
</span><span id="line-4"></span><span class="hs-pragma">{-# LANGUAGE MagicHash #-}</span><span>
</span><span id="line-5"></span><span class="hs-pragma">{-# LANGUAGE UnboxedTuples #-}</span><span>
</span><span id="line-6"></span><span>
</span><span id="line-7"></span><span class="hs-pragma">{-# LANGUAGE FlexibleInstances #-}</span><span>
</span><span id="line-8"></span><span class="hs-pragma">{-# LANGUAGE TypeInType #-}</span><span>
</span><span id="line-9"></span><span class="hs-pragma">{-# LANGUAGE TypeFamilies #-}</span><span>
</span><span id="line-10"></span><span>
</span><span id="line-11"></span><span class="hs-comment">{-|
Module      :  GHC.Exts.Heap
Copyright   :  (c) 2012 Joachim Breitner
License     :  BSD3
Maintainer  :  Joachim Breitner &lt;mail@joachim-breitner.de&gt;

With this module, you can investigate the heap representation of Haskell
values, i.e. to investigate sharing and lazy evaluation.
-}</span><span>
</span><span id="line-20"></span><span>
</span><span id="line-21"></span><span class="hs-keyword">module</span><span> </span><span class="hs-identifier">GHC.Exts.Heap</span><span> </span><span class="hs-special">(</span><span>
</span><span id="line-22"></span><span>    </span><span class="annot"><span class="hs-comment">-- * Closure types</span></span><span>
</span><span id="line-23"></span><span>      </span><span class="annot"><a href="GHC.Exts.Heap.Closures.html#Closure"><span class="hs-identifier">Closure</span></a></span><span>
</span><span id="line-24"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Exts.Heap.Closures.html#GenClosure"><span class="hs-identifier">GenClosure</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span>
</span><span id="line-25"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Exts.Heap.ClosureTypes.html#ClosureType"><span class="hs-identifier">ClosureType</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span>
</span><span id="line-26"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Exts.Heap.Closures.html#PrimType"><span class="hs-identifier">PrimType</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span>
</span><span id="line-27"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Exts.Heap.html#HasHeapRep"><span class="hs-identifier">HasHeapRep</span></a></span><span class="hs-special">(</span><span class="annot"><a href="GHC.Exts.Heap.html#getClosureData"><span class="hs-identifier">getClosureData</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-28"></span><span>
</span><span id="line-29"></span><span>    </span><span class="annot"><span class="hs-comment">-- * Info Table types</span></span><span>
</span><span id="line-30"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Exts.Heap.InfoTable.Types.html#StgInfoTable"><span class="hs-identifier">StgInfoTable</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span>
</span><span id="line-31"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Exts.Heap.InfoTable.Types.html#EntryFunPtr"><span class="hs-identifier">EntryFunPtr</span></a></span><span>
</span><span id="line-32"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Exts.Heap.InfoTable.Types.html#HalfWord"><span class="hs-identifier">HalfWord</span></a></span><span>
</span><span id="line-33"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Exts.Heap.InfoTable.Types.html#ItblCodes"><span class="hs-identifier">ItblCodes</span></a></span><span>
</span><span id="line-34"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Exts.Heap.InfoTable.html#itblSize"><span class="hs-identifier">itblSize</span></a></span><span>
</span><span id="line-35"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Exts.Heap.InfoTable.html#peekItbl"><span class="hs-identifier">peekItbl</span></a></span><span>
</span><span id="line-36"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Exts.Heap.InfoTable.html#pokeItbl"><span class="hs-identifier">pokeItbl</span></a></span><span>
</span><span id="line-37"></span><span>
</span><span id="line-38"></span><span>     </span><span class="annot"><span class="hs-comment">-- * Closure inspection</span></span><span>
</span><span id="line-39"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Exts.Heap.html#getBoxedClosureData"><span class="hs-identifier">getBoxedClosureData</span></a></span><span>
</span><span id="line-40"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Exts.Heap.Closures.html#allClosures"><span class="hs-identifier">allClosures</span></a></span><span>
</span><span id="line-41"></span><span>
</span><span id="line-42"></span><span>    </span><span class="annot"><span class="hs-comment">-- * Boxes</span></span><span>
</span><span id="line-43"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Exts.Heap.Closures.html#Box"><span class="hs-identifier">Box</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span>
</span><span id="line-44"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Exts.Heap.Closures.html#asBox"><span class="hs-identifier">asBox</span></a></span><span>
</span><span id="line-45"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Exts.Heap.Closures.html#areBoxesEqual"><span class="hs-identifier">areBoxesEqual</span></a></span><span>
</span><span id="line-46"></span><span>    </span><span class="hs-special">)</span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-47"></span><span>
</span><span id="line-48"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Prelude.html#"><span class="hs-identifier">Prelude</span></a></span><span>
</span><span id="line-49"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="GHC.Exts.Heap.Closures.html"><span class="hs-identifier">GHC.Exts.Heap.Closures</span></a></span><span>
</span><span id="line-50"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="GHC.Exts.Heap.ClosureTypes.html"><span class="hs-identifier">GHC.Exts.Heap.ClosureTypes</span></a></span><span>
</span><span id="line-51"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="GHC.Exts.Heap.Constants.html"><span class="hs-identifier">GHC.Exts.Heap.Constants</span></a></span><span class="hs-cpp">
#if defined(PROFILING)
</span><span class="hs-keyword">import</span><span> </span><span class="hs-identifier">GHC.Exts.Heap.InfoTableProf</span><span class="hs-cpp">
#else
</span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="GHC.Exts.Heap.InfoTable.html"><span class="hs-identifier">GHC.Exts.Heap.InfoTable</span></a></span><span class="hs-cpp">
#endif
</span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="GHC.Exts.Heap.Utils.html"><span class="hs-identifier">GHC.Exts.Heap.Utils</span></a></span><span>
</span><span id="line-58"></span><span>
</span><span id="line-59"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Control.Monad.html#"><span class="hs-identifier">Control.Monad</span></a></span><span>
</span><span id="line-60"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Data.Bits.html#"><span class="hs-identifier">Data.Bits</span></a></span><span>
</span><span id="line-61"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/GHC.Arr.html#"><span class="hs-identifier">GHC.Arr</span></a></span><span>
</span><span id="line-62"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/GHC.Exts.html#"><span class="hs-identifier">GHC.Exts</span></a></span><span>
</span><span id="line-63"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/GHC.Int.html#"><span class="hs-identifier">GHC.Int</span></a></span><span>
</span><span id="line-64"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#"><span class="hs-identifier">GHC.Word</span></a></span><span class="hs-cpp">

#include &quot;ghcconfig.h&quot;
</span><span>
</span><span id="line-68"></span><span class="hs-keyword">class</span><span> </span><span id="HasHeapRep"><span class="annot"><a href="GHC.Exts.Heap.html#HasHeapRep"><span class="hs-identifier hs-var">HasHeapRep</span></a></span></span><span> </span><span class="hs-special">(</span><span id="local-6989586621679059379"><span id="local-6989586621679059378"><span class="annot"><a href="#local-6989586621679059378"><span class="hs-identifier hs-type">a</span></a></span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Prim.html#TYPE"><span class="hs-identifier hs-type">TYPE</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679059379"><span class="hs-identifier hs-type">rep</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-69"></span><span>    </span><span id="getClosureData"><span class="annot"><a href="GHC.Exts.Heap.html#getClosureData"><span class="hs-identifier hs-type">getClosureData</span></a></span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="#local-6989586621679059378"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#IO"><span class="hs-identifier hs-type">IO</span></a></span><span> </span><span class="annot"><a href="GHC.Exts.Heap.Closures.html#Closure"><span class="hs-identifier hs-type">Closure</span></a></span><span>
</span><span id="line-70"></span><span>
</span><span id="line-71"></span><span id="local-6989586621679059382"><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="GHC.Exts.Heap.html#HasHeapRep"><span class="hs-identifier hs-type">HasHeapRep</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679059382"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Prim.html#TYPE"><span class="hs-identifier hs-type">TYPE</span></a></span><span> </span><span class="hs-special">'</span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#LiftedRep"><span class="hs-identifier hs-type">LiftedRep</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-72"></span><span>    </span><span id="local-6989586621679059294"><span class="annot"><span class="annottext">getClosureData :: a -&gt; IO Closure
</span><a href="#local-6989586621679059294"><span class="hs-identifier hs-var hs-var hs-var hs-var">getClosureData</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a -&gt; IO Closure
forall a. a -&gt; IO Closure
</span><a href="GHC.Exts.Heap.html#getClosure"><span class="hs-identifier hs-var">getClosure</span></a></span></span><span>
</span><span id="line-73"></span><span>
</span><span id="line-74"></span><span id="local-6989586621679059376"><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="GHC.Exts.Heap.html#HasHeapRep"><span class="hs-identifier hs-type">HasHeapRep</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679059376"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Prim.html#TYPE"><span class="hs-identifier hs-type">TYPE</span></a></span><span> </span><span class="hs-special">'</span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#UnliftedRep"><span class="hs-identifier hs-type">UnliftedRep</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-75"></span><span>    </span><span id="local-6989586621679059290"><span class="annot"><span class="annottext">getClosureData :: a -&gt; IO Closure
</span><a href="#local-6989586621679059290"><span class="hs-identifier hs-var hs-var hs-var hs-var">getClosureData</span></a></span></span><span> </span><span id="local-6989586621679059289"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679059289"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Any -&gt; IO Closure
forall a. a -&gt; IO Closure
</span><a href="GHC.Exts.Heap.html#getClosure"><span class="hs-identifier hs-var">getClosure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a -&gt; Any
</span><a href="../../base/src/Unsafe.Coerce.html#unsafeCoerce%23"><span class="hs-identifier hs-var">unsafeCoerce#</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679059289"><span class="hs-identifier hs-var">x</span></a></span><span class="hs-special">)</span></span><span>
</span><span id="line-76"></span><span>
</span><span id="line-77"></span><span id="local-6989586621679059370"><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Prim.html#Int%23"><span class="hs-identifier hs-type">Int#</span></a></span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#~"><span class="hs-operator hs-type">~</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679059370"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="GHC.Exts.Heap.html#HasHeapRep"><span class="hs-identifier hs-type">HasHeapRep</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679059370"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Prim.html#TYPE"><span class="hs-identifier hs-type">TYPE</span></a></span><span> </span><span class="hs-special">'</span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#IntRep"><span class="hs-identifier hs-type">IntRep</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-78"></span><span>    </span><span id="local-6989586621679059281"><span class="annot"><span class="annottext">getClosureData :: a -&gt; IO Closure
</span><a href="#local-6989586621679059281"><span class="hs-identifier hs-var hs-var hs-var hs-var">getClosureData</span></a></span></span><span> </span><span id="local-6989586621679059280"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679059280"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Closure -&gt; IO Closure
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">(Closure -&gt; IO Closure) -&gt; Closure -&gt; IO Closure
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span>
</span><span id="line-79"></span><span>        </span><span class="annot"><span class="annottext">IntClosure :: forall b. PrimType -&gt; Int -&gt; GenClosure b
</span><a href="GHC.Exts.Heap.Closures.html#IntClosure"><span class="hs-identifier hs-type">IntClosure</span></a></span><span> </span><span class="hs-special">{</span><span> </span><span class="annot"><span class="annottext">ptipe :: PrimType
</span><a href="GHC.Exts.Heap.Closures.html#ptipe"><span class="hs-identifier hs-var">ptipe</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">PrimType
</span><a href="GHC.Exts.Heap.Closures.html#PInt"><span class="hs-identifier hs-var">PInt</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">intVal :: Int
</span><a href="GHC.Exts.Heap.Closures.html#intVal"><span class="hs-identifier hs-var">intVal</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int# -&gt; Int
</span><a href="../../ghc-prim/src/GHC.Types.html#I%23"><span class="hs-identifier hs-var">I#</span></a></span><span> </span><span class="annot"><span class="annottext">a
Int#
</span><a href="#local-6989586621679059280"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="hs-special">}</span></span><span>
</span><span id="line-80"></span><span>
</span><span id="line-81"></span><span id="local-6989586621679059360"><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Prim.html#Word%23"><span class="hs-identifier hs-type">Word#</span></a></span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#~"><span class="hs-operator hs-type">~</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679059360"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="GHC.Exts.Heap.html#HasHeapRep"><span class="hs-identifier hs-type">HasHeapRep</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679059360"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Prim.html#TYPE"><span class="hs-identifier hs-type">TYPE</span></a></span><span> </span><span class="hs-special">'</span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#WordRep"><span class="hs-identifier hs-type">WordRep</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-82"></span><span>    </span><span id="local-6989586621679059269"><span class="annot"><span class="annottext">getClosureData :: a -&gt; IO Closure
</span><a href="#local-6989586621679059269"><span class="hs-identifier hs-var hs-var hs-var hs-var">getClosureData</span></a></span></span><span> </span><span id="local-6989586621679059268"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679059268"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Closure -&gt; IO Closure
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">(Closure -&gt; IO Closure) -&gt; Closure -&gt; IO Closure
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span>
</span><span id="line-83"></span><span>        </span><span class="annot"><span class="annottext">WordClosure :: forall b. PrimType -&gt; Word -&gt; GenClosure b
</span><a href="GHC.Exts.Heap.Closures.html#WordClosure"><span class="hs-identifier hs-type">WordClosure</span></a></span><span> </span><span class="hs-special">{</span><span> </span><span class="annot"><span class="annottext">ptipe :: PrimType
</span><a href="GHC.Exts.Heap.Closures.html#ptipe"><span class="hs-identifier hs-var">ptipe</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">PrimType
</span><a href="GHC.Exts.Heap.Closures.html#PWord"><span class="hs-identifier hs-var">PWord</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">wordVal :: Word
</span><a href="GHC.Exts.Heap.Closures.html#wordVal"><span class="hs-identifier hs-var">wordVal</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word# -&gt; Word
</span><a href="../../ghc-prim/src/GHC.Types.html#W%23"><span class="hs-identifier hs-var">W#</span></a></span><span> </span><span class="annot"><span class="annottext">a
Word#
</span><a href="#local-6989586621679059268"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="hs-special">}</span></span><span>
</span><span id="line-84"></span><span>
</span><span id="line-85"></span><span id="local-6989586621679059358"><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Prim.html#Int64%23"><span class="hs-identifier hs-type">Int64#</span></a></span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#~"><span class="hs-operator hs-type">~</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679059358"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="GHC.Exts.Heap.html#HasHeapRep"><span class="hs-identifier hs-type">HasHeapRep</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679059358"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Prim.html#TYPE"><span class="hs-identifier hs-type">TYPE</span></a></span><span> </span><span class="hs-special">'</span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int64Rep"><span class="hs-identifier hs-type">Int64Rep</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-86"></span><span>    </span><span id="local-6989586621679059260"><span class="annot"><span class="annottext">getClosureData :: a -&gt; IO Closure
</span><a href="#local-6989586621679059260"><span class="hs-identifier hs-var hs-var hs-var hs-var">getClosureData</span></a></span></span><span> </span><span id="local-6989586621679059259"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679059259"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Closure -&gt; IO Closure
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">(Closure -&gt; IO Closure) -&gt; Closure -&gt; IO Closure
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span>
</span><span id="line-87"></span><span>        </span><span class="annot"><span class="annottext">Int64Closure :: forall b. PrimType -&gt; Int64 -&gt; GenClosure b
</span><a href="GHC.Exts.Heap.Closures.html#Int64Closure"><span class="hs-identifier hs-type">Int64Closure</span></a></span><span> </span><span class="hs-special">{</span><span> </span><span class="annot"><span class="annottext">ptipe :: PrimType
</span><a href="GHC.Exts.Heap.Closures.html#ptipe"><span class="hs-identifier hs-var">ptipe</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">PrimType
</span><a href="GHC.Exts.Heap.Closures.html#PInt64"><span class="hs-identifier hs-var">PInt64</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">int64Val :: Int64
</span><a href="GHC.Exts.Heap.Closures.html#int64Val"><span class="hs-identifier hs-var">int64Val</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int# -&gt; Int64
</span><a href="../../base/src/GHC.Int.html#I64%23"><span class="hs-identifier hs-var">I64#</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a -&gt; Int#
</span><a href="../../base/src/Unsafe.Coerce.html#unsafeCoerce%23"><span class="hs-identifier hs-var">unsafeCoerce#</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679059259"><span class="hs-identifier hs-var">x</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">}</span></span><span>
</span><span id="line-88"></span><span>
</span><span id="line-89"></span><span id="local-6989586621679059356"><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Prim.html#Word64%23"><span class="hs-identifier hs-type">Word64#</span></a></span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#~"><span class="hs-operator hs-type">~</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679059356"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="GHC.Exts.Heap.html#HasHeapRep"><span class="hs-identifier hs-type">HasHeapRep</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679059356"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Prim.html#TYPE"><span class="hs-identifier hs-type">TYPE</span></a></span><span> </span><span class="hs-special">'</span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Word64Rep"><span class="hs-identifier hs-type">Word64Rep</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-90"></span><span>    </span><span id="local-6989586621679059250"><span class="annot"><span class="annottext">getClosureData :: a -&gt; IO Closure
</span><a href="#local-6989586621679059250"><span class="hs-identifier hs-var hs-var hs-var hs-var">getClosureData</span></a></span></span><span> </span><span id="local-6989586621679059249"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679059249"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Closure -&gt; IO Closure
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">(Closure -&gt; IO Closure) -&gt; Closure -&gt; IO Closure
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span>
</span><span id="line-91"></span><span>        </span><span class="annot"><span class="annottext">Word64Closure :: forall b. PrimType -&gt; Word64 -&gt; GenClosure b
</span><a href="GHC.Exts.Heap.Closures.html#Word64Closure"><span class="hs-identifier hs-type">Word64Closure</span></a></span><span> </span><span class="hs-special">{</span><span> </span><span class="annot"><span class="annottext">ptipe :: PrimType
</span><a href="GHC.Exts.Heap.Closures.html#ptipe"><span class="hs-identifier hs-var">ptipe</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">PrimType
</span><a href="GHC.Exts.Heap.Closures.html#PWord64"><span class="hs-identifier hs-var">PWord64</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">word64Val :: Word64
</span><a href="GHC.Exts.Heap.Closures.html#word64Val"><span class="hs-identifier hs-var">word64Val</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word# -&gt; Word64
</span><a href="../../base/src/GHC.Word.html#W64%23"><span class="hs-identifier hs-var">W64#</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a -&gt; Word#
</span><a href="../../base/src/Unsafe.Coerce.html#unsafeCoerce%23"><span class="hs-identifier hs-var">unsafeCoerce#</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679059249"><span class="hs-identifier hs-var">x</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">}</span></span><span>
</span><span id="line-92"></span><span>
</span><span id="line-93"></span><span id="local-6989586621679059354"><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Prim.html#Addr%23"><span class="hs-identifier hs-type">Addr#</span></a></span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#~"><span class="hs-operator hs-type">~</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679059354"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="GHC.Exts.Heap.html#HasHeapRep"><span class="hs-identifier hs-type">HasHeapRep</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679059354"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Prim.html#TYPE"><span class="hs-identifier hs-type">TYPE</span></a></span><span> </span><span class="hs-special">'</span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#AddrRep"><span class="hs-identifier hs-type">AddrRep</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-94"></span><span>    </span><span id="local-6989586621679059240"><span class="annot"><span class="annottext">getClosureData :: a -&gt; IO Closure
</span><a href="#local-6989586621679059240"><span class="hs-identifier hs-var hs-var hs-var hs-var">getClosureData</span></a></span></span><span> </span><span id="local-6989586621679059239"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679059239"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Closure -&gt; IO Closure
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">(Closure -&gt; IO Closure) -&gt; Closure -&gt; IO Closure
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span>
</span><span id="line-95"></span><span>        </span><span class="annot"><span class="annottext">AddrClosure :: forall b. PrimType -&gt; Int -&gt; GenClosure b
</span><a href="GHC.Exts.Heap.Closures.html#AddrClosure"><span class="hs-identifier hs-type">AddrClosure</span></a></span><span> </span><span class="hs-special">{</span><span> </span><span class="annot"><span class="annottext">ptipe :: PrimType
</span><a href="GHC.Exts.Heap.Closures.html#ptipe"><span class="hs-identifier hs-var">ptipe</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">PrimType
</span><a href="GHC.Exts.Heap.Closures.html#PAddr"><span class="hs-identifier hs-var">PAddr</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">addrVal :: Int
</span><a href="GHC.Exts.Heap.Closures.html#addrVal"><span class="hs-identifier hs-var">addrVal</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int# -&gt; Int
</span><a href="../../ghc-prim/src/GHC.Types.html#I%23"><span class="hs-identifier hs-var">I#</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a -&gt; Int#
</span><a href="../../base/src/Unsafe.Coerce.html#unsafeCoerce%23"><span class="hs-identifier hs-var">unsafeCoerce#</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679059239"><span class="hs-identifier hs-var">x</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">}</span></span><span>
</span><span id="line-96"></span><span>
</span><span id="line-97"></span><span id="local-6989586621679059352"><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Prim.html#Float%23"><span class="hs-identifier hs-type">Float#</span></a></span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#~"><span class="hs-operator hs-type">~</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679059352"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="GHC.Exts.Heap.html#HasHeapRep"><span class="hs-identifier hs-type">HasHeapRep</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679059352"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Prim.html#TYPE"><span class="hs-identifier hs-type">TYPE</span></a></span><span> </span><span class="hs-special">'</span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#FloatRep"><span class="hs-identifier hs-type">FloatRep</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-98"></span><span>    </span><span id="local-6989586621679059229"><span class="annot"><span class="annottext">getClosureData :: a -&gt; IO Closure
</span><a href="#local-6989586621679059229"><span class="hs-identifier hs-var hs-var hs-var hs-var">getClosureData</span></a></span></span><span> </span><span id="local-6989586621679059228"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679059228"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Closure -&gt; IO Closure
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">(Closure -&gt; IO Closure) -&gt; Closure -&gt; IO Closure
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span>
</span><span id="line-99"></span><span>        </span><span class="annot"><span class="annottext">FloatClosure :: forall b. PrimType -&gt; Float -&gt; GenClosure b
</span><a href="GHC.Exts.Heap.Closures.html#FloatClosure"><span class="hs-identifier hs-type">FloatClosure</span></a></span><span> </span><span class="hs-special">{</span><span> </span><span class="annot"><span class="annottext">ptipe :: PrimType
</span><a href="GHC.Exts.Heap.Closures.html#ptipe"><span class="hs-identifier hs-var">ptipe</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">PrimType
</span><a href="GHC.Exts.Heap.Closures.html#PFloat"><span class="hs-identifier hs-var">PFloat</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">floatVal :: Float
</span><a href="GHC.Exts.Heap.Closures.html#floatVal"><span class="hs-identifier hs-var">floatVal</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Float# -&gt; Float
</span><a href="../../ghc-prim/src/GHC.Types.html#F%23"><span class="hs-identifier hs-var">F#</span></a></span><span> </span><span class="annot"><span class="annottext">a
Float#
</span><a href="#local-6989586621679059228"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="hs-special">}</span></span><span>
</span><span id="line-100"></span><span>
</span><span id="line-101"></span><span id="local-6989586621679059350"><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Prim.html#Double%23"><span class="hs-identifier hs-type">Double#</span></a></span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#~"><span class="hs-operator hs-type">~</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679059350"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="GHC.Exts.Heap.html#HasHeapRep"><span class="hs-identifier hs-type">HasHeapRep</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679059350"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Prim.html#TYPE"><span class="hs-identifier hs-type">TYPE</span></a></span><span> </span><span class="hs-special">'</span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#DoubleRep"><span class="hs-identifier hs-type">DoubleRep</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-102"></span><span>    </span><span id="local-6989586621679059218"><span class="annot"><span class="annottext">getClosureData :: a -&gt; IO Closure
</span><a href="#local-6989586621679059218"><span class="hs-identifier hs-var hs-var hs-var hs-var">getClosureData</span></a></span></span><span> </span><span id="local-6989586621679059217"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679059217"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Closure -&gt; IO Closure
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">(Closure -&gt; IO Closure) -&gt; Closure -&gt; IO Closure
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span>
</span><span id="line-103"></span><span>        </span><span class="annot"><span class="annottext">DoubleClosure :: forall b. PrimType -&gt; Double -&gt; GenClosure b
</span><a href="GHC.Exts.Heap.Closures.html#DoubleClosure"><span class="hs-identifier hs-type">DoubleClosure</span></a></span><span> </span><span class="hs-special">{</span><span> </span><span class="annot"><span class="annottext">ptipe :: PrimType
</span><a href="GHC.Exts.Heap.Closures.html#ptipe"><span class="hs-identifier hs-var">ptipe</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">PrimType
</span><a href="GHC.Exts.Heap.Closures.html#PDouble"><span class="hs-identifier hs-var">PDouble</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">doubleVal :: Double
</span><a href="GHC.Exts.Heap.Closures.html#doubleVal"><span class="hs-identifier hs-var">doubleVal</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Double# -&gt; Double
</span><a href="../../ghc-prim/src/GHC.Types.html#D%23"><span class="hs-identifier hs-var">D#</span></a></span><span> </span><span class="annot"><span class="annottext">a
Double#
</span><a href="#local-6989586621679059217"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="hs-special">}</span></span><span>
</span><span id="line-104"></span><span>
</span><span id="line-105"></span><span class="hs-comment">-- | This returns the raw representation of the given argument. The second</span><span>
</span><span id="line-106"></span><span class="hs-comment">-- component of the triple is the raw words of the closure on the heap, and the</span><span>
</span><span id="line-107"></span><span class="hs-comment">-- third component is those words that are actually pointers. Once back in the</span><span>
</span><span id="line-108"></span><span class="hs-comment">-- Haskell world, the raw words that hold pointers may be outdated after a</span><span>
</span><span id="line-109"></span><span class="hs-comment">-- garbage collector run, but the corresponding values in 'Box's will still</span><span>
</span><span id="line-110"></span><span class="hs-comment">-- point to the correct value.</span><span>
</span><span id="line-111"></span><span id="local-6989586621679059349"><span class="annot"><a href="GHC.Exts.Heap.html#getClosureRaw"><span class="hs-identifier hs-type">getClosureRaw</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="#local-6989586621679059349"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#IO"><span class="hs-identifier hs-type">IO</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Ptr.html#Ptr"><span class="hs-identifier hs-type">Ptr</span></a></span><span> </span><span class="annot"><a href="GHC.Exts.Heap.InfoTable.Types.html#StgInfoTable"><span class="hs-identifier hs-type">StgInfoTable</span></a></span><span class="hs-special">,</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Word"><span class="hs-identifier hs-type">Word</span></a></span><span class="hs-special">]</span><span class="hs-special">,</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Exts.Heap.Closures.html#Box"><span class="hs-identifier hs-type">Box</span></a></span><span class="hs-special">]</span><span class="hs-special">)</span></span><span>
</span><span id="line-112"></span><span id="getClosureRaw"><span class="annot"><span class="annottext">getClosureRaw :: forall a. a -&gt; IO (Ptr StgInfoTable, [Word], [Box])
</span><a href="GHC.Exts.Heap.html#getClosureRaw"><span class="hs-identifier hs-var hs-var">getClosureRaw</span></a></span></span><span> </span><span id="local-6989586621679059197"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679059197"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-113"></span><span>    </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">a -&gt; (# Addr#, ByteArray#, Array# Any #)
forall a b. a -&gt; (# Addr#, ByteArray#, Array# b #)
</span><a href="../../ghc-prim/src/GHC.Prim.html#unpackClosure%23"><span class="hs-identifier hs-var">unpackClosure#</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679059197"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-114"></span><span class="hs-comment">-- This is a hack to cover the bootstrap compiler using the old version of</span><span>
</span><span id="line-115"></span><span class="hs-comment">-- 'unpackClosure'. The new 'unpackClosure' return values are not merely</span><span>
</span><span id="line-116"></span><span class="hs-comment">-- a reordering, so using the old version would not work.</span><span>
</span><span id="line-117"></span><span>        </span><span class="hs-special">(#</span><span> </span><span id="local-6989586621679059196"><span class="annot"><span class="annottext">Addr#
</span><a href="#local-6989586621679059196"><span class="hs-identifier hs-var">iptr</span></a></span></span><span class="hs-special">,</span><span> </span><span id="local-6989586621679059195"><span class="annot"><span class="annottext">ByteArray#
</span><a href="#local-6989586621679059195"><span class="hs-identifier hs-var">dat</span></a></span></span><span class="hs-special">,</span><span> </span><span id="local-6989586621679059194"><span class="annot"><span class="annottext">Array# Any
</span><a href="#local-6989586621679059194"><span class="hs-identifier hs-var">pointers</span></a></span></span><span> </span><span class="hs-special">#)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-118"></span><span>            </span><span class="hs-keyword">let</span><span> </span><span id="local-6989586621679059193"><span class="annot"><span class="annottext">nelems :: Int
</span><a href="#local-6989586621679059193"><span class="hs-identifier hs-var hs-var">nelems</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int# -&gt; Int
</span><a href="../../ghc-prim/src/GHC.Types.html#I%23"><span class="hs-identifier hs-var">I#</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ByteArray# -&gt; Int#
</span><a href="../../ghc-prim/src/GHC.Prim.html#sizeofByteArray%23"><span class="hs-identifier hs-var">sizeofByteArray#</span></a></span><span> </span><span class="annot"><span class="annottext">ByteArray#
</span><a href="#local-6989586621679059195"><span class="hs-identifier hs-var">dat</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Integral a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Real.html#div"><span class="hs-operator hs-var">`div`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="GHC.Exts.Heap.Constants.html#wORD_SIZE"><span class="hs-identifier hs-var">wORD_SIZE</span></a></span><span>
</span><span id="line-119"></span><span>                </span><span id="local-6989586621679059190"><span class="annot"><span class="annottext">end :: Int
</span><a href="#local-6989586621679059190"><span class="hs-identifier hs-var hs-var">end</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679059193"><span class="hs-identifier hs-var">nelems</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#-"><span class="hs-glyph hs-var">-</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span>
</span><span id="line-120"></span><span>                </span><span id="local-6989586621679059189"><span class="annot"><span class="annottext">rawWds :: [Word]
</span><a href="#local-6989586621679059189"><span class="hs-identifier hs-var hs-var">rawWds</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Word# -&gt; Word
</span><a href="../../ghc-prim/src/GHC.Types.html#W%23"><span class="hs-identifier hs-var">W#</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ByteArray# -&gt; Int# -&gt; Word#
</span><a href="../../ghc-prim/src/GHC.Prim.html#indexWordArray%23"><span class="hs-identifier hs-var">indexWordArray#</span></a></span><span> </span><span class="annot"><span class="annottext">ByteArray#
</span><a href="#local-6989586621679059195"><span class="hs-identifier hs-var">dat</span></a></span><span> </span><span class="annot"><span class="annottext">Int#
</span><a href="#local-6989586621679059188"><span class="hs-identifier hs-var">i</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">|</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#I%23"><span class="hs-identifier hs-type">I#</span></a></span><span> </span><span id="local-6989586621679059188"><span class="annot"><span class="annottext">Int#
</span><a href="#local-6989586621679059188"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span class="hs-glyph">..</span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679059190"><span class="hs-identifier hs-var">end</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-special">]</span><span>
</span><span id="line-121"></span><span>                </span><span id="local-6989586621679059187"><span class="annot"><span class="annottext">pelems :: Int
</span><a href="#local-6989586621679059187"><span class="hs-identifier hs-var hs-var">pelems</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int# -&gt; Int
</span><a href="../../ghc-prim/src/GHC.Types.html#I%23"><span class="hs-identifier hs-var">I#</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Array# Any -&gt; Int#
forall a. Array# a -&gt; Int#
</span><a href="../../ghc-prim/src/GHC.Prim.html#sizeofArray%23"><span class="hs-identifier hs-var">sizeofArray#</span></a></span><span> </span><span class="annot"><span class="annottext">Array# Any
</span><a href="#local-6989586621679059194"><span class="hs-identifier hs-var">pointers</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-122"></span><span>                </span><span id="local-6989586621679059186"><span class="annot"><span class="annottext">ptrList :: [Box]
</span><a href="#local-6989586621679059186"><span class="hs-identifier hs-var hs-var">ptrList</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Any -&gt; Box) -&gt; Array Int Any -&gt; [Box]
forall t b. (t -&gt; b) -&gt; Array Int t -&gt; [b]
</span><a href="GHC.Exts.Heap.html#amap%27"><span class="hs-identifier hs-var">amap'</span></a></span><span> </span><span class="annot"><span class="annottext">Any -&gt; Box
</span><a href="GHC.Exts.Heap.Closures.html#Box"><span class="hs-identifier hs-var">Box</span></a></span><span> </span><span class="annot"><span class="annottext">(Array Int Any -&gt; [Box]) -&gt; Array Int Any -&gt; [Box]
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int -&gt; Array# Any -&gt; Array Int Any
forall i e. i -&gt; i -&gt; Int -&gt; Array# e -&gt; Array i e
</span><a href="../../base/src/GHC.Arr.html#Array"><span class="hs-identifier hs-var">Array</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679059187"><span class="hs-identifier hs-var">pelems</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#-"><span class="hs-glyph hs-var">-</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679059187"><span class="hs-identifier hs-var">pelems</span></a></span><span> </span><span class="annot"><span class="annottext">Array# Any
</span><a href="#local-6989586621679059194"><span class="hs-identifier hs-var">pointers</span></a></span><span>
</span><span id="line-123"></span><span>            </span><span class="annot"><span class="annottext">(Ptr StgInfoTable, [Word], [Box])
-&gt; IO (Ptr StgInfoTable, [Word], [Box])
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Addr# -&gt; Ptr StgInfoTable
forall a. Addr# -&gt; Ptr a
</span><a href="../../base/src/GHC.Ptr.html#Ptr"><span class="hs-identifier hs-var">Ptr</span></a></span><span> </span><span class="annot"><span class="annottext">Addr#
</span><a href="#local-6989586621679059196"><span class="hs-identifier hs-var">iptr</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">[Word]
</span><a href="#local-6989586621679059189"><span class="hs-identifier hs-var">rawWds</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">[Box]
</span><a href="#local-6989586621679059186"><span class="hs-identifier hs-var">ptrList</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-124"></span><span>
</span><span id="line-125"></span><span class="hs-comment">-- From GHC.Runtime.Heap.Inspect</span><span>
</span><span id="line-126"></span><span id="local-6989586621679059337"><span id="local-6989586621679059338"><span class="annot"><a href="GHC.Exts.Heap.html#amap%27"><span class="hs-identifier hs-type">amap'</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679059338"><span class="hs-identifier hs-type">t</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679059337"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Arr.html#Array"><span class="hs-identifier hs-type">Array</span></a></span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679059338"><span class="hs-identifier hs-type">t</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679059337"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">]</span></span></span><span>
</span><span id="line-127"></span><span id="amap%27"><span class="annot"><span class="annottext">amap' :: forall t b. (t -&gt; b) -&gt; Array Int t -&gt; [b]
</span><a href="GHC.Exts.Heap.html#amap%27"><span class="hs-identifier hs-var hs-var">amap'</span></a></span></span><span> </span><span id="local-6989586621679059178"><span class="annot"><span class="annottext">t -&gt; b
</span><a href="#local-6989586621679059178"><span class="hs-identifier hs-var">f</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Arr.html#Array"><span class="hs-identifier hs-type">Array</span></a></span><span> </span><span id="local-6989586621679059177"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679059177"><span class="hs-identifier hs-var">i0</span></a></span></span><span> </span><span id="local-6989586621679059176"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679059176"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-identifier">_</span></span><span> </span><span id="local-6989586621679059175"><span class="annot"><span class="annottext">Array# t
</span><a href="#local-6989586621679059175"><span class="hs-identifier hs-var">arr#</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Int -&gt; b) -&gt; [Int] -&gt; [b]
forall a b. (a -&gt; b) -&gt; [a] -&gt; [b]
</span><a href="../../base/src/GHC.Base.html#map"><span class="hs-identifier hs-var">map</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; b
</span><a href="#local-6989586621679059174"><span class="hs-identifier hs-var">g</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span> </span><span class="hs-glyph">..</span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679059176"><span class="hs-identifier hs-var">i</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#-"><span class="hs-glyph hs-var">-</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679059177"><span class="hs-identifier hs-var">i0</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-128"></span><span>    </span><span class="hs-keyword">where</span><span> </span><span id="local-6989586621679059174"><span class="annot"><span class="annottext">g :: Int -&gt; b
</span><a href="#local-6989586621679059174"><span class="hs-identifier hs-var hs-var">g</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#I%23"><span class="hs-identifier hs-type">I#</span></a></span><span> </span><span id="local-6989586621679059173"><span class="annot"><span class="annottext">Int#
</span><a href="#local-6989586621679059173"><span class="hs-identifier hs-var">i#</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">Array# t -&gt; Int# -&gt; (# t #)
forall a. Array# a -&gt; Int# -&gt; (# a #)
</span><a href="../../ghc-prim/src/GHC.Prim.html#indexArray%23"><span class="hs-identifier hs-var">indexArray#</span></a></span><span> </span><span class="annot"><span class="annottext">Array# t
</span><a href="#local-6989586621679059175"><span class="hs-identifier hs-var">arr#</span></a></span><span> </span><span class="annot"><span class="annottext">Int#
</span><a href="#local-6989586621679059173"><span class="hs-identifier hs-var">i#</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-129"></span><span>                          </span><span class="hs-special">(#</span><span> </span><span id="local-6989586621679059172"><span class="annot"><span class="annottext">t
</span><a href="#local-6989586621679059172"><span class="hs-identifier hs-var">e</span></a></span></span><span> </span><span class="hs-special">#)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">t -&gt; b
</span><a href="#local-6989586621679059178"><span class="hs-identifier hs-var">f</span></a></span><span> </span><span class="annot"><span class="annottext">t
</span><a href="#local-6989586621679059172"><span class="hs-identifier hs-var">e</span></a></span><span>
</span><span id="line-130"></span><span>
</span><span id="line-131"></span><span class="hs-comment">-- | This function returns a parsed heap representation of the argument _at</span><span>
</span><span id="line-132"></span><span class="hs-comment">-- this moment_, even if it is unevaluated or an indirection or other exotic</span><span>
</span><span id="line-133"></span><span class="hs-comment">-- stuff.  Beware when passing something to this function, the same caveats as</span><span>
</span><span id="line-134"></span><span class="hs-comment">-- for 'asBox' apply.</span><span>
</span><span id="line-135"></span><span id="local-6989586621679059171"><span class="annot"><a href="GHC.Exts.Heap.html#getClosure"><span class="hs-identifier hs-type">getClosure</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="#local-6989586621679059171"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#IO"><span class="hs-identifier hs-type">IO</span></a></span><span> </span><span class="annot"><a href="GHC.Exts.Heap.Closures.html#Closure"><span class="hs-identifier hs-type">Closure</span></a></span></span><span>
</span><span id="line-136"></span><span id="getClosure"><span class="annot"><span class="annottext">getClosure :: forall a. a -&gt; IO Closure
</span><a href="GHC.Exts.Heap.html#getClosure"><span class="hs-identifier hs-var hs-var">getClosure</span></a></span></span><span> </span><span id="local-6989586621679058994"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679058994"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-137"></span><span>    </span><span class="hs-special">(</span><span id="local-6989586621679058993"><span class="annot"><span class="annottext">Ptr StgInfoTable
</span><a href="#local-6989586621679058993"><span class="hs-identifier hs-var">iptr</span></a></span></span><span class="hs-special">,</span><span> </span><span id="local-6989586621679058992"><span class="annot"><span class="annottext">[Word]
</span><a href="#local-6989586621679058992"><span class="hs-identifier hs-var">wds</span></a></span></span><span class="hs-special">,</span><span> </span><span id="local-6989586621679058991"><span class="annot"><span class="annottext">[Box]
</span><a href="#local-6989586621679058991"><span class="hs-identifier hs-var">pts</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">a -&gt; IO (Ptr StgInfoTable, [Word], [Box])
forall a. a -&gt; IO (Ptr StgInfoTable, [Word], [Box])
</span><a href="GHC.Exts.Heap.html#getClosureRaw"><span class="hs-identifier hs-var">getClosureRaw</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679058994"><span class="hs-identifier hs-var">x</span></a></span><span>
</span><span id="line-138"></span><span>    </span><span id="local-6989586621679058990"><span class="annot"><span class="annottext">StgInfoTable
</span><a href="#local-6989586621679058990"><span class="hs-identifier hs-var">itbl</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Ptr StgInfoTable -&gt; IO StgInfoTable
</span><a href="GHC.Exts.Heap.InfoTable.html#peekItbl"><span class="hs-identifier hs-var">peekItbl</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr StgInfoTable
</span><a href="#local-6989586621679058993"><span class="hs-identifier hs-var">iptr</span></a></span><span>
</span><span id="line-139"></span><span>    </span><span class="hs-comment">-- The remaining words after the header</span><span>
</span><span id="line-140"></span><span>    </span><span class="hs-keyword">let</span><span> </span><span id="local-6989586621679058989"><span class="annot"><span class="annottext">rawWds :: [Word]
</span><a href="#local-6989586621679058989"><span class="hs-identifier hs-var hs-var">rawWds</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int -&gt; [Word] -&gt; [Word]
forall a. Int -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.List.html#drop"><span class="hs-identifier hs-var">drop</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ClosureType -&gt; Int
</span><a href="GHC.Exts.Heap.ClosureTypes.html#closureTypeHeaderSize"><span class="hs-identifier hs-var">closureTypeHeaderSize</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">StgInfoTable -&gt; ClosureType
</span><a href="GHC.Exts.Heap.InfoTable.Types.html#tipe"><span class="hs-identifier hs-var hs-var">tipe</span></a></span><span> </span><span class="annot"><span class="annottext">StgInfoTable
</span><a href="#local-6989586621679058990"><span class="hs-identifier hs-var">itbl</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">[Word]
</span><a href="#local-6989586621679058992"><span class="hs-identifier hs-var">wds</span></a></span><span>
</span><span id="line-141"></span><span>    </span><span class="hs-comment">-- For data args in a pointers then non-pointers closure</span><span>
</span><span id="line-142"></span><span>    </span><span class="hs-comment">-- This is incorrect in non pointers-first setups</span><span>
</span><span id="line-143"></span><span>    </span><span class="hs-comment">-- not sure if that happens</span><span>
</span><span id="line-144"></span><span>        </span><span id="local-6989586621679058985"><span class="annot"><span class="annottext">npts :: [Word]
</span><a href="#local-6989586621679058985"><span class="hs-identifier hs-var hs-var">npts</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int -&gt; [Word] -&gt; [Word]
forall a. Int -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.List.html#drop"><span class="hs-identifier hs-var">drop</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ClosureType -&gt; Int
</span><a href="GHC.Exts.Heap.ClosureTypes.html#closureTypeHeaderSize"><span class="hs-identifier hs-var">closureTypeHeaderSize</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">StgInfoTable -&gt; ClosureType
</span><a href="GHC.Exts.Heap.InfoTable.Types.html#tipe"><span class="hs-identifier hs-var hs-var">tipe</span></a></span><span> </span><span class="annot"><span class="annottext">StgInfoTable
</span><a href="#local-6989586621679058990"><span class="hs-identifier hs-var">itbl</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#%2B"><span class="hs-operator hs-var">+</span></a></span><span> </span><span class="annot"><span class="annottext">[Box] -&gt; Int
forall (t :: * -&gt; *) a. Foldable t =&gt; t a -&gt; Int
</span><a href="../../base/src/Data.Foldable.html#length"><span class="hs-identifier hs-var">length</span></a></span><span> </span><span class="annot"><span class="annottext">[Box]
</span><a href="#local-6989586621679058991"><span class="hs-identifier hs-var">pts</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">[Word]
</span><a href="#local-6989586621679058992"><span class="hs-identifier hs-var">wds</span></a></span><span>
</span><span id="line-145"></span><span>    </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">StgInfoTable -&gt; ClosureType
</span><a href="GHC.Exts.Heap.InfoTable.Types.html#tipe"><span class="hs-identifier hs-var hs-var">tipe</span></a></span><span> </span><span class="annot"><span class="annottext">StgInfoTable
</span><a href="#local-6989586621679058990"><span class="hs-identifier hs-var">itbl</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-146"></span><span>        </span><span id="local-6989586621679058982"><span class="annot"><span class="annottext">ClosureType
</span><a href="#local-6989586621679058982"><span class="hs-identifier hs-var">t</span></a></span></span><span> </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">ClosureType
</span><a href="#local-6989586621679058982"><span class="hs-identifier hs-var">t</span></a></span><span> </span><span class="annot"><span class="annottext">ClosureType -&gt; ClosureType -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3E%3D"><span class="hs-operator hs-var">&gt;=</span></a></span><span> </span><span class="annot"><span class="annottext">ClosureType
</span><a href="GHC.Exts.Heap.ClosureTypes.html#CONSTR"><span class="hs-identifier hs-var">CONSTR</span></a></span><span> </span><span class="annot"><span class="annottext">Bool -&gt; Bool -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%26%26"><span class="hs-operator hs-var">&amp;&amp;</span></a></span><span> </span><span class="annot"><span class="annottext">ClosureType
</span><a href="#local-6989586621679058982"><span class="hs-identifier hs-var">t</span></a></span><span> </span><span class="annot"><span class="annottext">ClosureType -&gt; ClosureType -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3C%3D"><span class="hs-operator hs-var">&lt;=</span></a></span><span> </span><span class="annot"><span class="annottext">ClosureType
</span><a href="GHC.Exts.Heap.ClosureTypes.html#CONSTR_NOCAF"><span class="hs-identifier hs-var">CONSTR_NOCAF</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-147"></span><span>            </span><span class="hs-special">(</span><span id="local-6989586621679058977"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679058977"><span class="hs-identifier hs-var">p</span></a></span></span><span class="hs-special">,</span><span> </span><span id="local-6989586621679058976"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679058976"><span class="hs-identifier hs-var">m</span></a></span></span><span class="hs-special">,</span><span> </span><span id="local-6989586621679058975"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679058975"><span class="hs-identifier hs-var">n</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Ptr StgInfoTable -&gt; IO (String, String, String)
</span><a href="GHC.Exts.Heap.Utils.html#dataConNames"><span class="hs-identifier hs-var">dataConNames</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr StgInfoTable
</span><a href="#local-6989586621679058993"><span class="hs-identifier hs-var">iptr</span></a></span><span>
</span><span id="line-148"></span><span>            </span><span class="hs-keyword">if</span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679058976"><span class="hs-identifier hs-var">m</span></a></span><span> </span><span class="annot"><span class="annottext">String -&gt; String -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3D%3D"><span class="hs-operator hs-var">==</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;GHC.ByteCode.Instr&quot;</span></span><span> </span><span class="annot"><span class="annottext">Bool -&gt; Bool -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%26%26"><span class="hs-operator hs-var">&amp;&amp;</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679058975"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="annot"><span class="annottext">String -&gt; String -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3D%3D"><span class="hs-operator hs-var">==</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;BreakInfo&quot;</span></span><span>
</span><span id="line-149"></span><span>              </span><span class="hs-keyword">then</span><span> </span><span class="annot"><span class="annottext">Closure -&gt; IO Closure
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">(Closure -&gt; IO Closure) -&gt; Closure -&gt; IO Closure
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">StgInfoTable -&gt; Closure
forall b. StgInfoTable -&gt; GenClosure b
</span><a href="GHC.Exts.Heap.Closures.html#UnsupportedClosure"><span class="hs-identifier hs-var">UnsupportedClosure</span></a></span><span> </span><span class="annot"><span class="annottext">StgInfoTable
</span><a href="#local-6989586621679058990"><span class="hs-identifier hs-var">itbl</span></a></span><span>
</span><span id="line-150"></span><span>              </span><span class="hs-keyword">else</span><span> </span><span class="annot"><span class="annottext">Closure -&gt; IO Closure
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">(Closure -&gt; IO Closure) -&gt; Closure -&gt; IO Closure
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">StgInfoTable
-&gt; [Box] -&gt; [Word] -&gt; String -&gt; String -&gt; String -&gt; Closure
forall b.
StgInfoTable
-&gt; [b] -&gt; [Word] -&gt; String -&gt; String -&gt; String -&gt; GenClosure b
</span><a href="GHC.Exts.Heap.Closures.html#ConstrClosure"><span class="hs-identifier hs-var">ConstrClosure</span></a></span><span> </span><span class="annot"><span class="annottext">StgInfoTable
</span><a href="#local-6989586621679058990"><span class="hs-identifier hs-var">itbl</span></a></span><span> </span><span class="annot"><span class="annottext">[Box]
</span><a href="#local-6989586621679058991"><span class="hs-identifier hs-var">pts</span></a></span><span> </span><span class="annot"><span class="annottext">[Word]
</span><a href="#local-6989586621679058985"><span class="hs-identifier hs-var">npts</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679058977"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679058976"><span class="hs-identifier hs-var">m</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679058975"><span class="hs-identifier hs-var">n</span></a></span><span>
</span><span id="line-151"></span><span>
</span><span id="line-152"></span><span>        </span><span id="local-6989586621679058971"><span class="annot"><span class="annottext">ClosureType
</span><a href="#local-6989586621679058971"><span class="hs-identifier hs-var">t</span></a></span></span><span> </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">ClosureType
</span><a href="#local-6989586621679058971"><span class="hs-identifier hs-var">t</span></a></span><span> </span><span class="annot"><span class="annottext">ClosureType -&gt; ClosureType -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3E%3D"><span class="hs-operator hs-var">&gt;=</span></a></span><span> </span><span class="annot"><span class="annottext">ClosureType
</span><a href="GHC.Exts.Heap.ClosureTypes.html#THUNK"><span class="hs-identifier hs-var">THUNK</span></a></span><span> </span><span class="annot"><span class="annottext">Bool -&gt; Bool -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%26%26"><span class="hs-operator hs-var">&amp;&amp;</span></a></span><span> </span><span class="annot"><span class="annottext">ClosureType
</span><a href="#local-6989586621679058971"><span class="hs-identifier hs-var">t</span></a></span><span> </span><span class="annot"><span class="annottext">ClosureType -&gt; ClosureType -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3C%3D"><span class="hs-operator hs-var">&lt;=</span></a></span><span> </span><span class="annot"><span class="annottext">ClosureType
</span><a href="GHC.Exts.Heap.ClosureTypes.html#THUNK_STATIC"><span class="hs-identifier hs-var">THUNK_STATIC</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-153"></span><span>            </span><span class="annot"><span class="annottext">Closure -&gt; IO Closure
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">(Closure -&gt; IO Closure) -&gt; Closure -&gt; IO Closure
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">StgInfoTable -&gt; [Box] -&gt; [Word] -&gt; Closure
forall b. StgInfoTable -&gt; [b] -&gt; [Word] -&gt; GenClosure b
</span><a href="GHC.Exts.Heap.Closures.html#ThunkClosure"><span class="hs-identifier hs-var">ThunkClosure</span></a></span><span> </span><span class="annot"><span class="annottext">StgInfoTable
</span><a href="#local-6989586621679058990"><span class="hs-identifier hs-var">itbl</span></a></span><span> </span><span class="annot"><span class="annottext">[Box]
</span><a href="#local-6989586621679058991"><span class="hs-identifier hs-var">pts</span></a></span><span> </span><span class="annot"><span class="annottext">[Word]
</span><a href="#local-6989586621679058985"><span class="hs-identifier hs-var">npts</span></a></span><span>
</span><span id="line-154"></span><span>
</span><span id="line-155"></span><span>        </span><span class="annot"><span class="annottext">ClosureType
</span><a href="GHC.Exts.Heap.ClosureTypes.html#THUNK_SELECTOR"><span class="hs-identifier hs-var">THUNK_SELECTOR</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-156"></span><span>            </span><span class="annot"><span class="annottext">Bool -&gt; IO () -&gt; IO ()
forall (f :: * -&gt; *). Applicative f =&gt; Bool -&gt; f () -&gt; f ()
</span><a href="../../base/src/Control.Monad.html#unless"><span class="hs-identifier hs-var">unless</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Box] -&gt; Int
forall (t :: * -&gt; *) a. Foldable t =&gt; t a -&gt; Int
</span><a href="../../base/src/Data.Foldable.html#length"><span class="hs-identifier hs-var">length</span></a></span><span> </span><span class="annot"><span class="annottext">[Box]
</span><a href="#local-6989586621679058991"><span class="hs-identifier hs-var">pts</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3E%3D"><span class="hs-operator hs-var">&gt;=</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">(IO () -&gt; IO ()) -&gt; IO () -&gt; IO ()
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span>
</span><span id="line-157"></span><span>                </span><span class="annot"><span class="annottext">String -&gt; IO ()
forall (m :: * -&gt; *) a. MonadFail m =&gt; String -&gt; m a
</span><a href="../../base/src/Control.Monad.Fail.html#fail"><span class="hs-identifier hs-var">fail</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Expected at least 1 ptr argument to THUNK_SELECTOR&quot;</span></span><span>
</span><span id="line-158"></span><span>            </span><span class="annot"><span class="annottext">Closure -&gt; IO Closure
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">(Closure -&gt; IO Closure) -&gt; Closure -&gt; IO Closure
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">StgInfoTable -&gt; Box -&gt; Closure
forall b. StgInfoTable -&gt; b -&gt; GenClosure b
</span><a href="GHC.Exts.Heap.Closures.html#SelectorClosure"><span class="hs-identifier hs-var">SelectorClosure</span></a></span><span> </span><span class="annot"><span class="annottext">StgInfoTable
</span><a href="#local-6989586621679058990"><span class="hs-identifier hs-var">itbl</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Box] -&gt; Box
forall a. [a] -&gt; a
</span><a href="../../base/src/GHC.List.html#head"><span class="hs-identifier hs-var">head</span></a></span><span> </span><span class="annot"><span class="annottext">[Box]
</span><a href="#local-6989586621679058991"><span class="hs-identifier hs-var">pts</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-159"></span><span>
</span><span id="line-160"></span><span>        </span><span id="local-6989586621679058963"><span class="annot"><span class="annottext">ClosureType
</span><a href="#local-6989586621679058963"><span class="hs-identifier hs-var">t</span></a></span></span><span> </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">ClosureType
</span><a href="#local-6989586621679058963"><span class="hs-identifier hs-var">t</span></a></span><span> </span><span class="annot"><span class="annottext">ClosureType -&gt; ClosureType -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3E%3D"><span class="hs-operator hs-var">&gt;=</span></a></span><span> </span><span class="annot"><span class="annottext">ClosureType
</span><a href="GHC.Exts.Heap.ClosureTypes.html#FUN"><span class="hs-identifier hs-var">FUN</span></a></span><span> </span><span class="annot"><span class="annottext">Bool -&gt; Bool -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%26%26"><span class="hs-operator hs-var">&amp;&amp;</span></a></span><span> </span><span class="annot"><span class="annottext">ClosureType
</span><a href="#local-6989586621679058963"><span class="hs-identifier hs-var">t</span></a></span><span> </span><span class="annot"><span class="annottext">ClosureType -&gt; ClosureType -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3C%3D"><span class="hs-operator hs-var">&lt;=</span></a></span><span> </span><span class="annot"><span class="annottext">ClosureType
</span><a href="GHC.Exts.Heap.ClosureTypes.html#FUN_STATIC"><span class="hs-identifier hs-var">FUN_STATIC</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-161"></span><span>            </span><span class="annot"><span class="annottext">Closure -&gt; IO Closure
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">(Closure -&gt; IO Closure) -&gt; Closure -&gt; IO Closure
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">StgInfoTable -&gt; [Box] -&gt; [Word] -&gt; Closure
forall b. StgInfoTable -&gt; [b] -&gt; [Word] -&gt; GenClosure b
</span><a href="GHC.Exts.Heap.Closures.html#FunClosure"><span class="hs-identifier hs-var">FunClosure</span></a></span><span> </span><span class="annot"><span class="annottext">StgInfoTable
</span><a href="#local-6989586621679058990"><span class="hs-identifier hs-var">itbl</span></a></span><span> </span><span class="annot"><span class="annottext">[Box]
</span><a href="#local-6989586621679058991"><span class="hs-identifier hs-var">pts</span></a></span><span> </span><span class="annot"><span class="annottext">[Word]
</span><a href="#local-6989586621679058985"><span class="hs-identifier hs-var">npts</span></a></span><span>
</span><span id="line-162"></span><span>
</span><span id="line-163"></span><span>        </span><span class="annot"><span class="annottext">ClosureType
</span><a href="GHC.Exts.Heap.ClosureTypes.html#AP"><span class="hs-identifier hs-var">AP</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-164"></span><span>            </span><span class="annot"><span class="annottext">Bool -&gt; IO () -&gt; IO ()
forall (f :: * -&gt; *). Applicative f =&gt; Bool -&gt; f () -&gt; f ()
</span><a href="../../base/src/Control.Monad.html#unless"><span class="hs-identifier hs-var">unless</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Box] -&gt; Int
forall (t :: * -&gt; *) a. Foldable t =&gt; t a -&gt; Int
</span><a href="../../base/src/Data.Foldable.html#length"><span class="hs-identifier hs-var">length</span></a></span><span> </span><span class="annot"><span class="annottext">[Box]
</span><a href="#local-6989586621679058991"><span class="hs-identifier hs-var">pts</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3E%3D"><span class="hs-operator hs-var">&gt;=</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">(IO () -&gt; IO ()) -&gt; IO () -&gt; IO ()
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span>
</span><span id="line-165"></span><span>                </span><span class="annot"><span class="annottext">String -&gt; IO ()
forall (m :: * -&gt; *) a. MonadFail m =&gt; String -&gt; m a
</span><a href="../../base/src/Control.Monad.Fail.html#fail"><span class="hs-identifier hs-var">fail</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Expected at least 1 ptr argument to AP&quot;</span></span><span>
</span><span id="line-166"></span><span>            </span><span class="hs-comment">-- We expect at least the arity, n_args, and fun fields</span><span>
</span><span id="line-167"></span><span>            </span><span class="annot"><span class="annottext">Bool -&gt; IO () -&gt; IO ()
forall (f :: * -&gt; *). Applicative f =&gt; Bool -&gt; f () -&gt; f ()
</span><a href="../../base/src/Control.Monad.html#unless"><span class="hs-identifier hs-var">unless</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Word] -&gt; Int
forall (t :: * -&gt; *) a. Foldable t =&gt; t a -&gt; Int
</span><a href="../../base/src/Data.Foldable.html#length"><span class="hs-identifier hs-var">length</span></a></span><span> </span><span class="annot"><span class="annottext">[Word]
</span><a href="#local-6989586621679058989"><span class="hs-identifier hs-var">rawWds</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3E%3D"><span class="hs-operator hs-var">&gt;=</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">2</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">(IO () -&gt; IO ()) -&gt; IO () -&gt; IO ()
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span>
</span><span id="line-168"></span><span>                </span><span class="annot"><span class="annottext">String -&gt; IO ()
forall (m :: * -&gt; *) a. MonadFail m =&gt; String -&gt; m a
</span><a href="../../base/src/Control.Monad.Fail.html#fail"><span class="hs-identifier hs-var">fail</span></a></span><span> </span><span class="annot"><span class="annottext">(String -&gt; IO ()) -&gt; String -&gt; IO ()
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Expected at least 2 raw words to AP&quot;</span></span><span>
</span><span id="line-169"></span><span>            </span><span class="hs-keyword">let</span><span> </span><span id="local-6989586621679058958"><span class="annot"><span class="annottext">splitWord :: Word
</span><a href="#local-6989586621679058958"><span class="hs-identifier hs-var hs-var">splitWord</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[Word]
</span><a href="#local-6989586621679058989"><span class="hs-identifier hs-var">rawWds</span></a></span><span> </span><span class="annot"><span class="annottext">[Word] -&gt; Int -&gt; Word
forall a. [a] -&gt; Int -&gt; a
</span><a href="../../base/src/GHC.List.html#%21%21"><span class="hs-operator hs-var">!!</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span>
</span><span id="line-170"></span><span>            </span><span class="annot"><span class="annottext">Closure -&gt; IO Closure
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">(Closure -&gt; IO Closure) -&gt; Closure -&gt; IO Closure
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">StgInfoTable -&gt; HalfWord -&gt; HalfWord -&gt; Box -&gt; [Box] -&gt; Closure
forall b.
StgInfoTable -&gt; HalfWord -&gt; HalfWord -&gt; b -&gt; [b] -&gt; GenClosure b
</span><a href="GHC.Exts.Heap.Closures.html#APClosure"><span class="hs-identifier hs-var">APClosure</span></a></span><span> </span><span class="annot"><span class="annottext">StgInfoTable
</span><a href="#local-6989586621679058990"><span class="hs-identifier hs-var">itbl</span></a></span><span class="hs-cpp">
#if defined(WORDS_BIGENDIAN)
</span><span>                </span><span class="hs-special">(</span><span class="hs-identifier">fromIntegral</span><span> </span><span class="hs-operator">$</span><span> </span><span class="hs-identifier">shiftR</span><span> </span><span class="hs-identifier">splitWord</span><span> </span><span class="hs-special">(</span><span class="hs-identifier">wORD_SIZE_IN_BITS</span><span> </span><span class="hs-special">`</span><span class="hs-identifier">div</span><span class="hs-special">`</span><span> </span><span class="hs-number">2</span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-173"></span><span>                </span><span class="hs-special">(</span><span class="hs-identifier">fromIntegral</span><span> </span><span class="hs-identifier">splitWord</span><span class="hs-special">)</span><span class="hs-cpp">
#else
</span><span>                </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word -&gt; HalfWord
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621679058958"><span class="hs-identifier hs-var">splitWord</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-176"></span><span>                </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word -&gt; HalfWord
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">(Word -&gt; HalfWord) -&gt; Word -&gt; HalfWord
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">Word -&gt; Int -&gt; Word
forall a. Bits a =&gt; a -&gt; Int -&gt; a
</span><a href="../../base/src/Data.Bits.html#shiftR"><span class="hs-identifier hs-var">shiftR</span></a></span><span> </span><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621679058958"><span class="hs-identifier hs-var">splitWord</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><a href="GHC.Exts.Heap.Constants.html#wORD_SIZE_IN_BITS"><span class="hs-identifier hs-var">wORD_SIZE_IN_BITS</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Integral a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Real.html#div"><span class="hs-operator hs-var">`div`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">2</span></span><span class="hs-special">)</span><span class="hs-special">)</span><span class="hs-cpp">
#endif
</span><span>                </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Box] -&gt; Box
forall a. [a] -&gt; a
</span><a href="../../base/src/GHC.List.html#head"><span class="hs-identifier hs-var">head</span></a></span><span> </span><span class="annot"><span class="annottext">[Box]
</span><a href="#local-6989586621679058991"><span class="hs-identifier hs-var">pts</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Box] -&gt; [Box]
forall a. [a] -&gt; [a]
</span><a href="../../base/src/GHC.List.html#tail"><span class="hs-identifier hs-var">tail</span></a></span><span> </span><span class="annot"><span class="annottext">[Box]
</span><a href="#local-6989586621679058991"><span class="hs-identifier hs-var">pts</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-179"></span><span>
</span><span id="line-180"></span><span>        </span><span class="annot"><span class="annottext">ClosureType
</span><a href="GHC.Exts.Heap.ClosureTypes.html#PAP"><span class="hs-identifier hs-var">PAP</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-181"></span><span>            </span><span class="annot"><span class="annottext">Bool -&gt; IO () -&gt; IO ()
forall (f :: * -&gt; *). Applicative f =&gt; Bool -&gt; f () -&gt; f ()
</span><a href="../../base/src/Control.Monad.html#unless"><span class="hs-identifier hs-var">unless</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Box] -&gt; Int
forall (t :: * -&gt; *) a. Foldable t =&gt; t a -&gt; Int
</span><a href="../../base/src/Data.Foldable.html#length"><span class="hs-identifier hs-var">length</span></a></span><span> </span><span class="annot"><span class="annottext">[Box]
</span><a href="#local-6989586621679058991"><span class="hs-identifier hs-var">pts</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3E%3D"><span class="hs-operator hs-var">&gt;=</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">(IO () -&gt; IO ()) -&gt; IO () -&gt; IO ()
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span>
</span><span id="line-182"></span><span>                </span><span class="annot"><span class="annottext">String -&gt; IO ()
forall (m :: * -&gt; *) a. MonadFail m =&gt; String -&gt; m a
</span><a href="../../base/src/Control.Monad.Fail.html#fail"><span class="hs-identifier hs-var">fail</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Expected at least 1 ptr argument to PAP&quot;</span></span><span>
</span><span id="line-183"></span><span>            </span><span class="hs-comment">-- We expect at least the arity, n_args, and fun fields</span><span>
</span><span id="line-184"></span><span>            </span><span class="annot"><span class="annottext">Bool -&gt; IO () -&gt; IO ()
forall (f :: * -&gt; *). Applicative f =&gt; Bool -&gt; f () -&gt; f ()
</span><a href="../../base/src/Control.Monad.html#unless"><span class="hs-identifier hs-var">unless</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Word] -&gt; Int
forall (t :: * -&gt; *) a. Foldable t =&gt; t a -&gt; Int
</span><a href="../../base/src/Data.Foldable.html#length"><span class="hs-identifier hs-var">length</span></a></span><span> </span><span class="annot"><span class="annottext">[Word]
</span><a href="#local-6989586621679058989"><span class="hs-identifier hs-var">rawWds</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3E%3D"><span class="hs-operator hs-var">&gt;=</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">2</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">(IO () -&gt; IO ()) -&gt; IO () -&gt; IO ()
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span>
</span><span id="line-185"></span><span>                </span><span class="annot"><span class="annottext">String -&gt; IO ()
forall (m :: * -&gt; *) a. MonadFail m =&gt; String -&gt; m a
</span><a href="../../base/src/Control.Monad.Fail.html#fail"><span class="hs-identifier hs-var">fail</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Expected at least 2 raw words to PAP&quot;</span></span><span>
</span><span id="line-186"></span><span>            </span><span class="hs-keyword">let</span><span> </span><span id="local-6989586621679058951"><span class="annot"><span class="annottext">splitWord :: Word
</span><a href="#local-6989586621679058951"><span class="hs-identifier hs-var hs-var">splitWord</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[Word]
</span><a href="#local-6989586621679058989"><span class="hs-identifier hs-var">rawWds</span></a></span><span> </span><span class="annot"><span class="annottext">[Word] -&gt; Int -&gt; Word
forall a. [a] -&gt; Int -&gt; a
</span><a href="../../base/src/GHC.List.html#%21%21"><span class="hs-operator hs-var">!!</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span>
</span><span id="line-187"></span><span>            </span><span class="annot"><span class="annottext">Closure -&gt; IO Closure
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">(Closure -&gt; IO Closure) -&gt; Closure -&gt; IO Closure
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">StgInfoTable -&gt; HalfWord -&gt; HalfWord -&gt; Box -&gt; [Box] -&gt; Closure
forall b.
StgInfoTable -&gt; HalfWord -&gt; HalfWord -&gt; b -&gt; [b] -&gt; GenClosure b
</span><a href="GHC.Exts.Heap.Closures.html#PAPClosure"><span class="hs-identifier hs-var">PAPClosure</span></a></span><span> </span><span class="annot"><span class="annottext">StgInfoTable
</span><a href="#local-6989586621679058990"><span class="hs-identifier hs-var">itbl</span></a></span><span class="hs-cpp">
#if defined(WORDS_BIGENDIAN)
</span><span>                </span><span class="hs-special">(</span><span class="hs-identifier">fromIntegral</span><span> </span><span class="hs-operator">$</span><span> </span><span class="hs-identifier">shiftR</span><span> </span><span class="hs-identifier">splitWord</span><span> </span><span class="hs-special">(</span><span class="hs-identifier">wORD_SIZE_IN_BITS</span><span> </span><span class="hs-special">`</span><span class="hs-identifier">div</span><span class="hs-special">`</span><span> </span><span class="hs-number">2</span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-190"></span><span>                </span><span class="hs-special">(</span><span class="hs-identifier">fromIntegral</span><span> </span><span class="hs-identifier">splitWord</span><span class="hs-special">)</span><span class="hs-cpp">
#else
</span><span>                </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word -&gt; HalfWord
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621679058951"><span class="hs-identifier hs-var">splitWord</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-193"></span><span>                </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word -&gt; HalfWord
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">(Word -&gt; HalfWord) -&gt; Word -&gt; HalfWord
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">Word -&gt; Int -&gt; Word
forall a. Bits a =&gt; a -&gt; Int -&gt; a
</span><a href="../../base/src/Data.Bits.html#shiftR"><span class="hs-identifier hs-var">shiftR</span></a></span><span> </span><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621679058951"><span class="hs-identifier hs-var">splitWord</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><a href="GHC.Exts.Heap.Constants.html#wORD_SIZE_IN_BITS"><span class="hs-identifier hs-var">wORD_SIZE_IN_BITS</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Integral a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Real.html#div"><span class="hs-operator hs-var">`div`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">2</span></span><span class="hs-special">)</span><span class="hs-special">)</span><span class="hs-cpp">
#endif
</span><span>                </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Box] -&gt; Box
forall a. [a] -&gt; a
</span><a href="../../base/src/GHC.List.html#head"><span class="hs-identifier hs-var">head</span></a></span><span> </span><span class="annot"><span class="annottext">[Box]
</span><a href="#local-6989586621679058991"><span class="hs-identifier hs-var">pts</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Box] -&gt; [Box]
forall a. [a] -&gt; [a]
</span><a href="../../base/src/GHC.List.html#tail"><span class="hs-identifier hs-var">tail</span></a></span><span> </span><span class="annot"><span class="annottext">[Box]
</span><a href="#local-6989586621679058991"><span class="hs-identifier hs-var">pts</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-196"></span><span>
</span><span id="line-197"></span><span>        </span><span class="annot"><span class="annottext">ClosureType
</span><a href="GHC.Exts.Heap.ClosureTypes.html#AP_STACK"><span class="hs-identifier hs-var">AP_STACK</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-198"></span><span>            </span><span class="annot"><span class="annottext">Bool -&gt; IO () -&gt; IO ()
forall (f :: * -&gt; *). Applicative f =&gt; Bool -&gt; f () -&gt; f ()
</span><a href="../../base/src/Control.Monad.html#unless"><span class="hs-identifier hs-var">unless</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Box] -&gt; Int
forall (t :: * -&gt; *) a. Foldable t =&gt; t a -&gt; Int
</span><a href="../../base/src/Data.Foldable.html#length"><span class="hs-identifier hs-var">length</span></a></span><span> </span><span class="annot"><span class="annottext">[Box]
</span><a href="#local-6989586621679058991"><span class="hs-identifier hs-var">pts</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3E%3D"><span class="hs-operator hs-var">&gt;=</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">(IO () -&gt; IO ()) -&gt; IO () -&gt; IO ()
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span>
</span><span id="line-199"></span><span>                </span><span class="annot"><span class="annottext">String -&gt; IO ()
forall (m :: * -&gt; *) a. MonadFail m =&gt; String -&gt; m a
</span><a href="../../base/src/Control.Monad.Fail.html#fail"><span class="hs-identifier hs-var">fail</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Expected at least 1 ptr argument to AP_STACK&quot;</span></span><span>
</span><span id="line-200"></span><span>            </span><span class="annot"><span class="annottext">Closure -&gt; IO Closure
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">(Closure -&gt; IO Closure) -&gt; Closure -&gt; IO Closure
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">StgInfoTable -&gt; Box -&gt; [Box] -&gt; Closure
forall b. StgInfoTable -&gt; b -&gt; [b] -&gt; GenClosure b
</span><a href="GHC.Exts.Heap.Closures.html#APStackClosure"><span class="hs-identifier hs-var">APStackClosure</span></a></span><span> </span><span class="annot"><span class="annottext">StgInfoTable
</span><a href="#local-6989586621679058990"><span class="hs-identifier hs-var">itbl</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Box] -&gt; Box
forall a. [a] -&gt; a
</span><a href="../../base/src/GHC.List.html#head"><span class="hs-identifier hs-var">head</span></a></span><span> </span><span class="annot"><span class="annottext">[Box]
</span><a href="#local-6989586621679058991"><span class="hs-identifier hs-var">pts</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Box] -&gt; [Box]
forall a. [a] -&gt; [a]
</span><a href="../../base/src/GHC.List.html#tail"><span class="hs-identifier hs-var">tail</span></a></span><span> </span><span class="annot"><span class="annottext">[Box]
</span><a href="#local-6989586621679058991"><span class="hs-identifier hs-var">pts</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-201"></span><span>
</span><span id="line-202"></span><span>        </span><span class="annot"><span class="annottext">ClosureType
</span><a href="GHC.Exts.Heap.ClosureTypes.html#IND"><span class="hs-identifier hs-var">IND</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-203"></span><span>            </span><span class="annot"><span class="annottext">Bool -&gt; IO () -&gt; IO ()
forall (f :: * -&gt; *). Applicative f =&gt; Bool -&gt; f () -&gt; f ()
</span><a href="../../base/src/Control.Monad.html#unless"><span class="hs-identifier hs-var">unless</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Box] -&gt; Int
forall (t :: * -&gt; *) a. Foldable t =&gt; t a -&gt; Int
</span><a href="../../base/src/Data.Foldable.html#length"><span class="hs-identifier hs-var">length</span></a></span><span> </span><span class="annot"><span class="annottext">[Box]
</span><a href="#local-6989586621679058991"><span class="hs-identifier hs-var">pts</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3E%3D"><span class="hs-operator hs-var">&gt;=</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">(IO () -&gt; IO ()) -&gt; IO () -&gt; IO ()
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span>
</span><span id="line-204"></span><span>                </span><span class="annot"><span class="annottext">String -&gt; IO ()
forall (m :: * -&gt; *) a. MonadFail m =&gt; String -&gt; m a
</span><a href="../../base/src/Control.Monad.Fail.html#fail"><span class="hs-identifier hs-var">fail</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Expected at least 1 ptr argument to IND&quot;</span></span><span>
</span><span id="line-205"></span><span>            </span><span class="annot"><span class="annottext">Closure -&gt; IO Closure
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">(Closure -&gt; IO Closure) -&gt; Closure -&gt; IO Closure
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">StgInfoTable -&gt; Box -&gt; Closure
forall b. StgInfoTable -&gt; b -&gt; GenClosure b
</span><a href="GHC.Exts.Heap.Closures.html#IndClosure"><span class="hs-identifier hs-var">IndClosure</span></a></span><span> </span><span class="annot"><span class="annottext">StgInfoTable
</span><a href="#local-6989586621679058990"><span class="hs-identifier hs-var">itbl</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Box] -&gt; Box
forall a. [a] -&gt; a
</span><a href="../../base/src/GHC.List.html#head"><span class="hs-identifier hs-var">head</span></a></span><span> </span><span class="annot"><span class="annottext">[Box]
</span><a href="#local-6989586621679058991"><span class="hs-identifier hs-var">pts</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-206"></span><span>
</span><span id="line-207"></span><span>        </span><span class="annot"><span class="annottext">ClosureType
</span><a href="GHC.Exts.Heap.ClosureTypes.html#IND_STATIC"><span class="hs-identifier hs-var">IND_STATIC</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-208"></span><span>            </span><span class="annot"><span class="annottext">Bool -&gt; IO () -&gt; IO ()
forall (f :: * -&gt; *). Applicative f =&gt; Bool -&gt; f () -&gt; f ()
</span><a href="../../base/src/Control.Monad.html#unless"><span class="hs-identifier hs-var">unless</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Box] -&gt; Int
forall (t :: * -&gt; *) a. Foldable t =&gt; t a -&gt; Int
</span><a href="../../base/src/Data.Foldable.html#length"><span class="hs-identifier hs-var">length</span></a></span><span> </span><span class="annot"><span class="annottext">[Box]
</span><a href="#local-6989586621679058991"><span class="hs-identifier hs-var">pts</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3E%3D"><span class="hs-operator hs-var">&gt;=</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">(IO () -&gt; IO ()) -&gt; IO () -&gt; IO ()
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span>
</span><span id="line-209"></span><span>                </span><span class="annot"><span class="annottext">String -&gt; IO ()
forall (m :: * -&gt; *) a. MonadFail m =&gt; String -&gt; m a
</span><a href="../../base/src/Control.Monad.Fail.html#fail"><span class="hs-identifier hs-var">fail</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Expected at least 1 ptr argument to IND_STATIC&quot;</span></span><span>
</span><span id="line-210"></span><span>            </span><span class="annot"><span class="annottext">Closure -&gt; IO Closure
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">(Closure -&gt; IO Closure) -&gt; Closure -&gt; IO Closure
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">StgInfoTable -&gt; Box -&gt; Closure
forall b. StgInfoTable -&gt; b -&gt; GenClosure b
</span><a href="GHC.Exts.Heap.Closures.html#IndClosure"><span class="hs-identifier hs-var">IndClosure</span></a></span><span> </span><span class="annot"><span class="annottext">StgInfoTable
</span><a href="#local-6989586621679058990"><span class="hs-identifier hs-var">itbl</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Box] -&gt; Box
forall a. [a] -&gt; a
</span><a href="../../base/src/GHC.List.html#head"><span class="hs-identifier hs-var">head</span></a></span><span> </span><span class="annot"><span class="annottext">[Box]
</span><a href="#local-6989586621679058991"><span class="hs-identifier hs-var">pts</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-211"></span><span>
</span><span id="line-212"></span><span>        </span><span class="annot"><span class="annottext">ClosureType
</span><a href="GHC.Exts.Heap.ClosureTypes.html#BLACKHOLE"><span class="hs-identifier hs-var">BLACKHOLE</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-213"></span><span>            </span><span class="annot"><span class="annottext">Bool -&gt; IO () -&gt; IO ()
forall (f :: * -&gt; *). Applicative f =&gt; Bool -&gt; f () -&gt; f ()
</span><a href="../../base/src/Control.Monad.html#unless"><span class="hs-identifier hs-var">unless</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Box] -&gt; Int
forall (t :: * -&gt; *) a. Foldable t =&gt; t a -&gt; Int
</span><a href="../../base/src/Data.Foldable.html#length"><span class="hs-identifier hs-var">length</span></a></span><span> </span><span class="annot"><span class="annottext">[Box]
</span><a href="#local-6989586621679058991"><span class="hs-identifier hs-var">pts</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3E%3D"><span class="hs-operator hs-var">&gt;=</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">(IO () -&gt; IO ()) -&gt; IO () -&gt; IO ()
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span>
</span><span id="line-214"></span><span>                </span><span class="annot"><span class="annottext">String -&gt; IO ()
forall (m :: * -&gt; *) a. MonadFail m =&gt; String -&gt; m a
</span><a href="../../base/src/Control.Monad.Fail.html#fail"><span class="hs-identifier hs-var">fail</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Expected at least 1 ptr argument to BLACKHOLE&quot;</span></span><span>
</span><span id="line-215"></span><span>            </span><span class="annot"><span class="annottext">Closure -&gt; IO Closure
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">(Closure -&gt; IO Closure) -&gt; Closure -&gt; IO Closure
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">StgInfoTable -&gt; Box -&gt; Closure
forall b. StgInfoTable -&gt; b -&gt; GenClosure b
</span><a href="GHC.Exts.Heap.Closures.html#BlackholeClosure"><span class="hs-identifier hs-var">BlackholeClosure</span></a></span><span> </span><span class="annot"><span class="annottext">StgInfoTable
</span><a href="#local-6989586621679058990"><span class="hs-identifier hs-var">itbl</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Box] -&gt; Box
forall a. [a] -&gt; a
</span><a href="../../base/src/GHC.List.html#head"><span class="hs-identifier hs-var">head</span></a></span><span> </span><span class="annot"><span class="annottext">[Box]
</span><a href="#local-6989586621679058991"><span class="hs-identifier hs-var">pts</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-216"></span><span>
</span><span id="line-217"></span><span>        </span><span class="annot"><span class="annottext">ClosureType
</span><a href="GHC.Exts.Heap.ClosureTypes.html#BCO"><span class="hs-identifier hs-var">BCO</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-218"></span><span>            </span><span class="annot"><span class="annottext">Bool -&gt; IO () -&gt; IO ()
forall (f :: * -&gt; *). Applicative f =&gt; Bool -&gt; f () -&gt; f ()
</span><a href="../../base/src/Control.Monad.html#unless"><span class="hs-identifier hs-var">unless</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Box] -&gt; Int
forall (t :: * -&gt; *) a. Foldable t =&gt; t a -&gt; Int
</span><a href="../../base/src/Data.Foldable.html#length"><span class="hs-identifier hs-var">length</span></a></span><span> </span><span class="annot"><span class="annottext">[Box]
</span><a href="#local-6989586621679058991"><span class="hs-identifier hs-var">pts</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3E%3D"><span class="hs-operator hs-var">&gt;=</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">3</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">(IO () -&gt; IO ()) -&gt; IO () -&gt; IO ()
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span>
</span><span id="line-219"></span><span>                </span><span class="annot"><span class="annottext">String -&gt; IO ()
forall (m :: * -&gt; *) a. MonadFail m =&gt; String -&gt; m a
</span><a href="../../base/src/Control.Monad.Fail.html#fail"><span class="hs-identifier hs-var">fail</span></a></span><span> </span><span class="annot"><span class="annottext">(String -&gt; IO ()) -&gt; String -&gt; IO ()
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Expected at least 3 ptr argument to BCO, found &quot;</span></span><span>
</span><span id="line-220"></span><span>                        </span><span class="annot"><span class="annottext">String -&gt; String -&gt; String
forall a. [a] -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.Base.html#%2B%2B"><span class="hs-operator hs-var">++</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; String
forall a. Show a =&gt; a -&gt; String
</span><a href="../../base/src/GHC.Show.html#show"><span class="hs-identifier hs-var">show</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Box] -&gt; Int
forall (t :: * -&gt; *) a. Foldable t =&gt; t a -&gt; Int
</span><a href="../../base/src/Data.Foldable.html#length"><span class="hs-identifier hs-var">length</span></a></span><span> </span><span class="annot"><span class="annottext">[Box]
</span><a href="#local-6989586621679058991"><span class="hs-identifier hs-var">pts</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-221"></span><span>            </span><span class="annot"><span class="annottext">Bool -&gt; IO () -&gt; IO ()
forall (f :: * -&gt; *). Applicative f =&gt; Bool -&gt; f () -&gt; f ()
</span><a href="../../base/src/Control.Monad.html#unless"><span class="hs-identifier hs-var">unless</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Word] -&gt; Int
forall (t :: * -&gt; *) a. Foldable t =&gt; t a -&gt; Int
</span><a href="../../base/src/Data.Foldable.html#length"><span class="hs-identifier hs-var">length</span></a></span><span> </span><span class="annot"><span class="annottext">[Word]
</span><a href="#local-6989586621679058989"><span class="hs-identifier hs-var">rawWds</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3E%3D"><span class="hs-operator hs-var">&gt;=</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">4</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">(IO () -&gt; IO ()) -&gt; IO () -&gt; IO ()
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span>
</span><span id="line-222"></span><span>                </span><span class="annot"><span class="annottext">String -&gt; IO ()
forall (m :: * -&gt; *) a. MonadFail m =&gt; String -&gt; m a
</span><a href="../../base/src/Control.Monad.Fail.html#fail"><span class="hs-identifier hs-var">fail</span></a></span><span> </span><span class="annot"><span class="annottext">(String -&gt; IO ()) -&gt; String -&gt; IO ()
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Expected at least 4 words to BCO, found &quot;</span></span><span>
</span><span id="line-223"></span><span>                        </span><span class="annot"><span class="annottext">String -&gt; String -&gt; String
forall a. [a] -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.Base.html#%2B%2B"><span class="hs-operator hs-var">++</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; String
forall a. Show a =&gt; a -&gt; String
</span><a href="../../base/src/GHC.Show.html#show"><span class="hs-identifier hs-var">show</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Word] -&gt; Int
forall (t :: * -&gt; *) a. Foldable t =&gt; t a -&gt; Int
</span><a href="../../base/src/Data.Foldable.html#length"><span class="hs-identifier hs-var">length</span></a></span><span> </span><span class="annot"><span class="annottext">[Word]
</span><a href="#local-6989586621679058989"><span class="hs-identifier hs-var">rawWds</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-224"></span><span>            </span><span class="hs-keyword">let</span><span> </span><span id="local-6989586621679058940"><span class="annot"><span class="annottext">splitWord :: Word
</span><a href="#local-6989586621679058940"><span class="hs-identifier hs-var hs-var">splitWord</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[Word]
</span><a href="#local-6989586621679058989"><span class="hs-identifier hs-var">rawWds</span></a></span><span> </span><span class="annot"><span class="annottext">[Word] -&gt; Int -&gt; Word
forall a. [a] -&gt; Int -&gt; a
</span><a href="../../base/src/GHC.List.html#%21%21"><span class="hs-operator hs-var">!!</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">3</span></span><span>
</span><span id="line-225"></span><span>            </span><span class="annot"><span class="annottext">Closure -&gt; IO Closure
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">(Closure -&gt; IO Closure) -&gt; Closure -&gt; IO Closure
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">StgInfoTable
-&gt; Box -&gt; Box -&gt; Box -&gt; HalfWord -&gt; HalfWord -&gt; [Word] -&gt; Closure
forall b.
StgInfoTable
-&gt; b -&gt; b -&gt; b -&gt; HalfWord -&gt; HalfWord -&gt; [Word] -&gt; GenClosure b
</span><a href="GHC.Exts.Heap.Closures.html#BCOClosure"><span class="hs-identifier hs-var">BCOClosure</span></a></span><span> </span><span class="annot"><span class="annottext">StgInfoTable
</span><a href="#local-6989586621679058990"><span class="hs-identifier hs-var">itbl</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Box]
</span><a href="#local-6989586621679058991"><span class="hs-identifier hs-var">pts</span></a></span><span> </span><span class="annot"><span class="annottext">[Box] -&gt; Int -&gt; Box
forall a. [a] -&gt; Int -&gt; a
</span><a href="../../base/src/GHC.List.html#%21%21"><span class="hs-operator hs-var">!!</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Box]
</span><a href="#local-6989586621679058991"><span class="hs-identifier hs-var">pts</span></a></span><span> </span><span class="annot"><span class="annottext">[Box] -&gt; Int -&gt; Box
forall a. [a] -&gt; Int -&gt; a
</span><a href="../../base/src/GHC.List.html#%21%21"><span class="hs-operator hs-var">!!</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Box]
</span><a href="#local-6989586621679058991"><span class="hs-identifier hs-var">pts</span></a></span><span> </span><span class="annot"><span class="annottext">[Box] -&gt; Int -&gt; Box
forall a. [a] -&gt; Int -&gt; a
</span><a href="../../base/src/GHC.List.html#%21%21"><span class="hs-operator hs-var">!!</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">2</span></span><span class="hs-special">)</span><span class="hs-cpp">
#if defined(WORDS_BIGENDIAN)
</span><span>                </span><span class="hs-special">(</span><span class="hs-identifier">fromIntegral</span><span> </span><span class="hs-operator">$</span><span> </span><span class="hs-identifier">shiftR</span><span> </span><span class="hs-identifier">splitWord</span><span> </span><span class="hs-special">(</span><span class="hs-identifier">wORD_SIZE_IN_BITS</span><span> </span><span class="hs-special">`</span><span class="hs-identifier">div</span><span class="hs-special">`</span><span> </span><span class="hs-number">2</span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-228"></span><span>                </span><span class="hs-special">(</span><span class="hs-identifier">fromIntegral</span><span> </span><span class="hs-identifier">splitWord</span><span class="hs-special">)</span><span class="hs-cpp">
#else
</span><span>                </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word -&gt; HalfWord
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621679058940"><span class="hs-identifier hs-var">splitWord</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-231"></span><span>                </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word -&gt; HalfWord
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">(Word -&gt; HalfWord) -&gt; Word -&gt; HalfWord
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">Word -&gt; Int -&gt; Word
forall a. Bits a =&gt; a -&gt; Int -&gt; a
</span><a href="../../base/src/Data.Bits.html#shiftR"><span class="hs-identifier hs-var">shiftR</span></a></span><span> </span><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621679058940"><span class="hs-identifier hs-var">splitWord</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><a href="GHC.Exts.Heap.Constants.html#wORD_SIZE_IN_BITS"><span class="hs-identifier hs-var">wORD_SIZE_IN_BITS</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Integral a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Real.html#div"><span class="hs-operator hs-var">`div`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">2</span></span><span class="hs-special">)</span><span class="hs-special">)</span><span class="hs-cpp">
#endif
</span><span>                </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int -&gt; [Word] -&gt; [Word]
forall a. Int -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.List.html#drop"><span class="hs-identifier hs-var">drop</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">4</span></span><span> </span><span class="annot"><span class="annottext">[Word]
</span><a href="#local-6989586621679058989"><span class="hs-identifier hs-var">rawWds</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-234"></span><span>
</span><span id="line-235"></span><span>        </span><span class="annot"><span class="annottext">ClosureType
</span><a href="GHC.Exts.Heap.ClosureTypes.html#ARR_WORDS"><span class="hs-identifier hs-var">ARR_WORDS</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-236"></span><span>            </span><span class="annot"><span class="annottext">Bool -&gt; IO () -&gt; IO ()
forall (f :: * -&gt; *). Applicative f =&gt; Bool -&gt; f () -&gt; f ()
</span><a href="../../base/src/Control.Monad.html#unless"><span class="hs-identifier hs-var">unless</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Word] -&gt; Int
forall (t :: * -&gt; *) a. Foldable t =&gt; t a -&gt; Int
</span><a href="../../base/src/Data.Foldable.html#length"><span class="hs-identifier hs-var">length</span></a></span><span> </span><span class="annot"><span class="annottext">[Word]
</span><a href="#local-6989586621679058989"><span class="hs-identifier hs-var">rawWds</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3E%3D"><span class="hs-operator hs-var">&gt;=</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">(IO () -&gt; IO ()) -&gt; IO () -&gt; IO ()
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span>
</span><span id="line-237"></span><span>                </span><span class="annot"><span class="annottext">String -&gt; IO ()
forall (m :: * -&gt; *) a. MonadFail m =&gt; String -&gt; m a
</span><a href="../../base/src/Control.Monad.Fail.html#fail"><span class="hs-identifier hs-var">fail</span></a></span><span> </span><span class="annot"><span class="annottext">(String -&gt; IO ()) -&gt; String -&gt; IO ()
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Expected at least 1 words to ARR_WORDS, found &quot;</span></span><span>
</span><span id="line-238"></span><span>                        </span><span class="annot"><span class="annottext">String -&gt; String -&gt; String
forall a. [a] -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.Base.html#%2B%2B"><span class="hs-operator hs-var">++</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; String
forall a. Show a =&gt; a -&gt; String
</span><a href="../../base/src/GHC.Show.html#show"><span class="hs-identifier hs-var">show</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Word] -&gt; Int
forall (t :: * -&gt; *) a. Foldable t =&gt; t a -&gt; Int
</span><a href="../../base/src/Data.Foldable.html#length"><span class="hs-identifier hs-var">length</span></a></span><span> </span><span class="annot"><span class="annottext">[Word]
</span><a href="#local-6989586621679058989"><span class="hs-identifier hs-var">rawWds</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-239"></span><span>            </span><span class="annot"><span class="annottext">Closure -&gt; IO Closure
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">(Closure -&gt; IO Closure) -&gt; Closure -&gt; IO Closure
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">StgInfoTable -&gt; Word -&gt; [Word] -&gt; Closure
forall b. StgInfoTable -&gt; Word -&gt; [Word] -&gt; GenClosure b
</span><a href="GHC.Exts.Heap.Closures.html#ArrWordsClosure"><span class="hs-identifier hs-var">ArrWordsClosure</span></a></span><span> </span><span class="annot"><span class="annottext">StgInfoTable
</span><a href="#local-6989586621679058990"><span class="hs-identifier hs-var">itbl</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Word] -&gt; Word
forall a. [a] -&gt; a
</span><a href="../../base/src/GHC.List.html#head"><span class="hs-identifier hs-var">head</span></a></span><span> </span><span class="annot"><span class="annottext">[Word]
</span><a href="#local-6989586621679058989"><span class="hs-identifier hs-var">rawWds</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Word] -&gt; [Word]
forall a. [a] -&gt; [a]
</span><a href="../../base/src/GHC.List.html#tail"><span class="hs-identifier hs-var">tail</span></a></span><span> </span><span class="annot"><span class="annottext">[Word]
</span><a href="#local-6989586621679058989"><span class="hs-identifier hs-var">rawWds</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-240"></span><span>
</span><span id="line-241"></span><span>        </span><span id="local-6989586621679058936"><span class="annot"><span class="annottext">ClosureType
</span><a href="#local-6989586621679058936"><span class="hs-identifier hs-var">t</span></a></span></span><span> </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">ClosureType
</span><a href="#local-6989586621679058936"><span class="hs-identifier hs-var">t</span></a></span><span> </span><span class="annot"><span class="annottext">ClosureType -&gt; ClosureType -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3E%3D"><span class="hs-operator hs-var">&gt;=</span></a></span><span> </span><span class="annot"><span class="annottext">ClosureType
</span><a href="GHC.Exts.Heap.ClosureTypes.html#MUT_ARR_PTRS_CLEAN"><span class="hs-identifier hs-var">MUT_ARR_PTRS_CLEAN</span></a></span><span> </span><span class="annot"><span class="annottext">Bool -&gt; Bool -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%26%26"><span class="hs-operator hs-var">&amp;&amp;</span></a></span><span> </span><span class="annot"><span class="annottext">ClosureType
</span><a href="#local-6989586621679058936"><span class="hs-identifier hs-var">t</span></a></span><span> </span><span class="annot"><span class="annottext">ClosureType -&gt; ClosureType -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3C%3D"><span class="hs-operator hs-var">&lt;=</span></a></span><span> </span><span class="annot"><span class="annottext">ClosureType
</span><a href="GHC.Exts.Heap.ClosureTypes.html#MUT_ARR_PTRS_FROZEN_CLEAN"><span class="hs-identifier hs-var">MUT_ARR_PTRS_FROZEN_CLEAN</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-242"></span><span>            </span><span class="annot"><span class="annottext">Bool -&gt; IO () -&gt; IO ()
forall (f :: * -&gt; *). Applicative f =&gt; Bool -&gt; f () -&gt; f ()
</span><a href="../../base/src/Control.Monad.html#unless"><span class="hs-identifier hs-var">unless</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Word] -&gt; Int
forall (t :: * -&gt; *) a. Foldable t =&gt; t a -&gt; Int
</span><a href="../../base/src/Data.Foldable.html#length"><span class="hs-identifier hs-var">length</span></a></span><span> </span><span class="annot"><span class="annottext">[Word]
</span><a href="#local-6989586621679058989"><span class="hs-identifier hs-var">rawWds</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3E%3D"><span class="hs-operator hs-var">&gt;=</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">2</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">(IO () -&gt; IO ()) -&gt; IO () -&gt; IO ()
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span>
</span><span id="line-243"></span><span>                </span><span class="annot"><span class="annottext">String -&gt; IO ()
forall (m :: * -&gt; *) a. MonadFail m =&gt; String -&gt; m a
</span><a href="../../base/src/Control.Monad.Fail.html#fail"><span class="hs-identifier hs-var">fail</span></a></span><span> </span><span class="annot"><span class="annottext">(String -&gt; IO ()) -&gt; String -&gt; IO ()
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Expected at least 2 words to MUT_ARR_PTRS_* &quot;</span></span><span>
</span><span id="line-244"></span><span>                        </span><span class="annot"><span class="annottext">String -&gt; String -&gt; String
forall a. [a] -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.Base.html#%2B%2B"><span class="hs-operator hs-var">++</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;found &quot;</span></span><span> </span><span class="annot"><span class="annottext">String -&gt; String -&gt; String
forall a. [a] -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.Base.html#%2B%2B"><span class="hs-operator hs-var">++</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; String
forall a. Show a =&gt; a -&gt; String
</span><a href="../../base/src/GHC.Show.html#show"><span class="hs-identifier hs-var">show</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Word] -&gt; Int
forall (t :: * -&gt; *) a. Foldable t =&gt; t a -&gt; Int
</span><a href="../../base/src/Data.Foldable.html#length"><span class="hs-identifier hs-var">length</span></a></span><span> </span><span class="annot"><span class="annottext">[Word]
</span><a href="#local-6989586621679058989"><span class="hs-identifier hs-var">rawWds</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-245"></span><span>            </span><span class="annot"><span class="annottext">Closure -&gt; IO Closure
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">(Closure -&gt; IO Closure) -&gt; Closure -&gt; IO Closure
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">StgInfoTable -&gt; Word -&gt; Word -&gt; [Box] -&gt; Closure
forall b. StgInfoTable -&gt; Word -&gt; Word -&gt; [b] -&gt; GenClosure b
</span><a href="GHC.Exts.Heap.Closures.html#MutArrClosure"><span class="hs-identifier hs-var">MutArrClosure</span></a></span><span> </span><span class="annot"><span class="annottext">StgInfoTable
</span><a href="#local-6989586621679058990"><span class="hs-identifier hs-var">itbl</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Word]
</span><a href="#local-6989586621679058989"><span class="hs-identifier hs-var">rawWds</span></a></span><span> </span><span class="annot"><span class="annottext">[Word] -&gt; Int -&gt; Word
forall a. [a] -&gt; Int -&gt; a
</span><a href="../../base/src/GHC.List.html#%21%21"><span class="hs-operator hs-var">!!</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Word]
</span><a href="#local-6989586621679058989"><span class="hs-identifier hs-var">rawWds</span></a></span><span> </span><span class="annot"><span class="annottext">[Word] -&gt; Int -&gt; Word
forall a. [a] -&gt; Int -&gt; a
</span><a href="../../base/src/GHC.List.html#%21%21"><span class="hs-operator hs-var">!!</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">[Box]
</span><a href="#local-6989586621679058991"><span class="hs-identifier hs-var">pts</span></a></span><span>
</span><span id="line-246"></span><span>
</span><span id="line-247"></span><span>        </span><span id="local-6989586621679058932"><span class="annot"><span class="annottext">ClosureType
</span><a href="#local-6989586621679058932"><span class="hs-identifier hs-var">t</span></a></span></span><span> </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">ClosureType
</span><a href="#local-6989586621679058932"><span class="hs-identifier hs-var">t</span></a></span><span> </span><span class="annot"><span class="annottext">ClosureType -&gt; ClosureType -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3E%3D"><span class="hs-operator hs-var">&gt;=</span></a></span><span> </span><span class="annot"><span class="annottext">ClosureType
</span><a href="GHC.Exts.Heap.ClosureTypes.html#SMALL_MUT_ARR_PTRS_CLEAN"><span class="hs-identifier hs-var">SMALL_MUT_ARR_PTRS_CLEAN</span></a></span><span> </span><span class="annot"><span class="annottext">Bool -&gt; Bool -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%26%26"><span class="hs-operator hs-var">&amp;&amp;</span></a></span><span> </span><span class="annot"><span class="annottext">ClosureType
</span><a href="#local-6989586621679058932"><span class="hs-identifier hs-var">t</span></a></span><span> </span><span class="annot"><span class="annottext">ClosureType -&gt; ClosureType -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3C%3D"><span class="hs-operator hs-var">&lt;=</span></a></span><span> </span><span class="annot"><span class="annottext">ClosureType
</span><a href="GHC.Exts.Heap.ClosureTypes.html#SMALL_MUT_ARR_PTRS_FROZEN_CLEAN"><span class="hs-identifier hs-var">SMALL_MUT_ARR_PTRS_FROZEN_CLEAN</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-248"></span><span>            </span><span class="annot"><span class="annottext">Bool -&gt; IO () -&gt; IO ()
forall (f :: * -&gt; *). Applicative f =&gt; Bool -&gt; f () -&gt; f ()
</span><a href="../../base/src/Control.Monad.html#unless"><span class="hs-identifier hs-var">unless</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Word] -&gt; Int
forall (t :: * -&gt; *) a. Foldable t =&gt; t a -&gt; Int
</span><a href="../../base/src/Data.Foldable.html#length"><span class="hs-identifier hs-var">length</span></a></span><span> </span><span class="annot"><span class="annottext">[Word]
</span><a href="#local-6989586621679058989"><span class="hs-identifier hs-var">rawWds</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3E%3D"><span class="hs-operator hs-var">&gt;=</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">(IO () -&gt; IO ()) -&gt; IO () -&gt; IO ()
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span>
</span><span id="line-249"></span><span>                </span><span class="annot"><span class="annottext">String -&gt; IO ()
forall (m :: * -&gt; *) a. MonadFail m =&gt; String -&gt; m a
</span><a href="../../base/src/Control.Monad.Fail.html#fail"><span class="hs-identifier hs-var">fail</span></a></span><span> </span><span class="annot"><span class="annottext">(String -&gt; IO ()) -&gt; String -&gt; IO ()
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Expected at least 1 word to SMALL_MUT_ARR_PTRS_* &quot;</span></span><span>
</span><span id="line-250"></span><span>                        </span><span class="annot"><span class="annottext">String -&gt; String -&gt; String
forall a. [a] -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.Base.html#%2B%2B"><span class="hs-operator hs-var">++</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;found &quot;</span></span><span> </span><span class="annot"><span class="annottext">String -&gt; String -&gt; String
forall a. [a] -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.Base.html#%2B%2B"><span class="hs-operator hs-var">++</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; String
forall a. Show a =&gt; a -&gt; String
</span><a href="../../base/src/GHC.Show.html#show"><span class="hs-identifier hs-var">show</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Word] -&gt; Int
forall (t :: * -&gt; *) a. Foldable t =&gt; t a -&gt; Int
</span><a href="../../base/src/Data.Foldable.html#length"><span class="hs-identifier hs-var">length</span></a></span><span> </span><span class="annot"><span class="annottext">[Word]
</span><a href="#local-6989586621679058989"><span class="hs-identifier hs-var">rawWds</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-251"></span><span>            </span><span class="annot"><span class="annottext">Closure -&gt; IO Closure
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">(Closure -&gt; IO Closure) -&gt; Closure -&gt; IO Closure
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">StgInfoTable -&gt; Word -&gt; [Box] -&gt; Closure
forall b. StgInfoTable -&gt; Word -&gt; [b] -&gt; GenClosure b
</span><a href="GHC.Exts.Heap.Closures.html#SmallMutArrClosure"><span class="hs-identifier hs-var">SmallMutArrClosure</span></a></span><span> </span><span class="annot"><span class="annottext">StgInfoTable
</span><a href="#local-6989586621679058990"><span class="hs-identifier hs-var">itbl</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Word]
</span><a href="#local-6989586621679058989"><span class="hs-identifier hs-var">rawWds</span></a></span><span> </span><span class="annot"><span class="annottext">[Word] -&gt; Int -&gt; Word
forall a. [a] -&gt; Int -&gt; a
</span><a href="../../base/src/GHC.List.html#%21%21"><span class="hs-operator hs-var">!!</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">[Box]
</span><a href="#local-6989586621679058991"><span class="hs-identifier hs-var">pts</span></a></span><span>
</span><span id="line-252"></span><span>
</span><span id="line-253"></span><span>        </span><span id="local-6989586621679058928"><span class="annot"><span class="annottext">ClosureType
</span><a href="#local-6989586621679058928"><span class="hs-identifier hs-var">t</span></a></span></span><span> </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">ClosureType
</span><a href="#local-6989586621679058928"><span class="hs-identifier hs-var">t</span></a></span><span> </span><span class="annot"><span class="annottext">ClosureType -&gt; ClosureType -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3D%3D"><span class="hs-operator hs-var">==</span></a></span><span> </span><span class="annot"><span class="annottext">ClosureType
</span><a href="GHC.Exts.Heap.ClosureTypes.html#MUT_VAR_CLEAN"><span class="hs-identifier hs-var">MUT_VAR_CLEAN</span></a></span><span> </span><span class="annot"><span class="annottext">Bool -&gt; Bool -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%7C%7C"><span class="hs-operator hs-var">||</span></a></span><span> </span><span class="annot"><span class="annottext">ClosureType
</span><a href="#local-6989586621679058928"><span class="hs-identifier hs-var">t</span></a></span><span> </span><span class="annot"><span class="annottext">ClosureType -&gt; ClosureType -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3D%3D"><span class="hs-operator hs-var">==</span></a></span><span> </span><span class="annot"><span class="annottext">ClosureType
</span><a href="GHC.Exts.Heap.ClosureTypes.html#MUT_VAR_DIRTY"><span class="hs-identifier hs-var">MUT_VAR_DIRTY</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span>
</span><span id="line-254"></span><span>            </span><span class="annot"><span class="annottext">Closure -&gt; IO Closure
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">(Closure -&gt; IO Closure) -&gt; Closure -&gt; IO Closure
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">StgInfoTable -&gt; Box -&gt; Closure
forall b. StgInfoTable -&gt; b -&gt; GenClosure b
</span><a href="GHC.Exts.Heap.Closures.html#MutVarClosure"><span class="hs-identifier hs-var">MutVarClosure</span></a></span><span> </span><span class="annot"><span class="annottext">StgInfoTable
</span><a href="#local-6989586621679058990"><span class="hs-identifier hs-var">itbl</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Box] -&gt; Box
forall a. [a] -&gt; a
</span><a href="../../base/src/GHC.List.html#head"><span class="hs-identifier hs-var">head</span></a></span><span> </span><span class="annot"><span class="annottext">[Box]
</span><a href="#local-6989586621679058991"><span class="hs-identifier hs-var">pts</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-255"></span><span>
</span><span id="line-256"></span><span>        </span><span id="local-6989586621679058923"><span class="annot"><span class="annottext">ClosureType
</span><a href="#local-6989586621679058923"><span class="hs-identifier hs-var">t</span></a></span></span><span> </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">ClosureType
</span><a href="#local-6989586621679058923"><span class="hs-identifier hs-var">t</span></a></span><span> </span><span class="annot"><span class="annottext">ClosureType -&gt; ClosureType -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3D%3D"><span class="hs-operator hs-var">==</span></a></span><span> </span><span class="annot"><span class="annottext">ClosureType
</span><a href="GHC.Exts.Heap.ClosureTypes.html#MVAR_CLEAN"><span class="hs-identifier hs-var">MVAR_CLEAN</span></a></span><span> </span><span class="annot"><span class="annottext">Bool -&gt; Bool -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%7C%7C"><span class="hs-operator hs-var">||</span></a></span><span> </span><span class="annot"><span class="annottext">ClosureType
</span><a href="#local-6989586621679058923"><span class="hs-identifier hs-var">t</span></a></span><span> </span><span class="annot"><span class="annottext">ClosureType -&gt; ClosureType -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3D%3D"><span class="hs-operator hs-var">==</span></a></span><span> </span><span class="annot"><span class="annottext">ClosureType
</span><a href="GHC.Exts.Heap.ClosureTypes.html#MVAR_DIRTY"><span class="hs-identifier hs-var">MVAR_DIRTY</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-257"></span><span>            </span><span class="annot"><span class="annottext">Bool -&gt; IO () -&gt; IO ()
forall (f :: * -&gt; *). Applicative f =&gt; Bool -&gt; f () -&gt; f ()
</span><a href="../../base/src/Control.Monad.html#unless"><span class="hs-identifier hs-var">unless</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Box] -&gt; Int
forall (t :: * -&gt; *) a. Foldable t =&gt; t a -&gt; Int
</span><a href="../../base/src/Data.Foldable.html#length"><span class="hs-identifier hs-var">length</span></a></span><span> </span><span class="annot"><span class="annottext">[Box]
</span><a href="#local-6989586621679058991"><span class="hs-identifier hs-var">pts</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3E%3D"><span class="hs-operator hs-var">&gt;=</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">3</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">(IO () -&gt; IO ()) -&gt; IO () -&gt; IO ()
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span>
</span><span id="line-258"></span><span>                </span><span class="annot"><span class="annottext">String -&gt; IO ()
forall (m :: * -&gt; *) a. MonadFail m =&gt; String -&gt; m a
</span><a href="../../base/src/Control.Monad.Fail.html#fail"><span class="hs-identifier hs-var">fail</span></a></span><span> </span><span class="annot"><span class="annottext">(String -&gt; IO ()) -&gt; String -&gt; IO ()
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Expected at least 3 ptrs to MVAR, found &quot;</span></span><span>
</span><span id="line-259"></span><span>                        </span><span class="annot"><span class="annottext">String -&gt; String -&gt; String
forall a. [a] -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.Base.html#%2B%2B"><span class="hs-operator hs-var">++</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; String
forall a. Show a =&gt; a -&gt; String
</span><a href="../../base/src/GHC.Show.html#show"><span class="hs-identifier hs-var">show</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Box] -&gt; Int
forall (t :: * -&gt; *) a. Foldable t =&gt; t a -&gt; Int
</span><a href="../../base/src/Data.Foldable.html#length"><span class="hs-identifier hs-var">length</span></a></span><span> </span><span class="annot"><span class="annottext">[Box]
</span><a href="#local-6989586621679058991"><span class="hs-identifier hs-var">pts</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-260"></span><span>            </span><span class="annot"><span class="annottext">Closure -&gt; IO Closure
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">(Closure -&gt; IO Closure) -&gt; Closure -&gt; IO Closure
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">StgInfoTable -&gt; Box -&gt; Box -&gt; Box -&gt; Closure
forall b. StgInfoTable -&gt; b -&gt; b -&gt; b -&gt; GenClosure b
</span><a href="GHC.Exts.Heap.Closures.html#MVarClosure"><span class="hs-identifier hs-var">MVarClosure</span></a></span><span> </span><span class="annot"><span class="annottext">StgInfoTable
</span><a href="#local-6989586621679058990"><span class="hs-identifier hs-var">itbl</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Box]
</span><a href="#local-6989586621679058991"><span class="hs-identifier hs-var">pts</span></a></span><span> </span><span class="annot"><span class="annottext">[Box] -&gt; Int -&gt; Box
forall a. [a] -&gt; Int -&gt; a
</span><a href="../../base/src/GHC.List.html#%21%21"><span class="hs-operator hs-var">!!</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Box]
</span><a href="#local-6989586621679058991"><span class="hs-identifier hs-var">pts</span></a></span><span> </span><span class="annot"><span class="annottext">[Box] -&gt; Int -&gt; Box
forall a. [a] -&gt; Int -&gt; a
</span><a href="../../base/src/GHC.List.html#%21%21"><span class="hs-operator hs-var">!!</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Box]
</span><a href="#local-6989586621679058991"><span class="hs-identifier hs-var">pts</span></a></span><span> </span><span class="annot"><span class="annottext">[Box] -&gt; Int -&gt; Box
forall a. [a] -&gt; Int -&gt; a
</span><a href="../../base/src/GHC.List.html#%21%21"><span class="hs-operator hs-var">!!</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">2</span></span><span class="hs-special">)</span><span>
</span><span id="line-261"></span><span>
</span><span id="line-262"></span><span>        </span><span class="annot"><span class="annottext">ClosureType
</span><a href="GHC.Exts.Heap.ClosureTypes.html#BLOCKING_QUEUE"><span class="hs-identifier hs-var">BLOCKING_QUEUE</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span>
</span><span id="line-263"></span><span>            </span><span class="annot"><span class="annottext">Closure -&gt; IO Closure
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">(Closure -&gt; IO Closure) -&gt; Closure -&gt; IO Closure
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">StgInfoTable -&gt; [Box] -&gt; [Word] -&gt; Closure
forall b. StgInfoTable -&gt; [b] -&gt; [Word] -&gt; GenClosure b
</span><a href="GHC.Exts.Heap.Closures.html#OtherClosure"><span class="hs-identifier hs-var">OtherClosure</span></a></span><span> </span><span class="annot"><span class="annottext">StgInfoTable
</span><a href="#local-6989586621679058990"><span class="hs-identifier hs-var">itbl</span></a></span><span> </span><span class="annot"><span class="annottext">[Box]
</span><a href="#local-6989586621679058991"><span class="hs-identifier hs-var">pts</span></a></span><span> </span><span class="annot"><span class="annottext">[Word]
</span><a href="#local-6989586621679058992"><span class="hs-identifier hs-var">wds</span></a></span><span>
</span><span id="line-264"></span><span>        </span><span class="hs-comment">--    pure $ BlockingQueueClosure itbl</span><span>
</span><span id="line-265"></span><span>        </span><span class="hs-comment">--        (pts !! 0) (pts !! 1) (pts !! 2) (pts !! 3)</span><span>
</span><span id="line-266"></span><span>
</span><span id="line-267"></span><span>        </span><span class="hs-comment">--  pure $ OtherClosure itbl pts wds</span><span>
</span><span id="line-268"></span><span>        </span><span class="hs-comment">--</span><span>
</span><span id="line-269"></span><span>
</span><span id="line-270"></span><span>        </span><span class="annot"><span class="annottext">ClosureType
</span><a href="GHC.Exts.Heap.ClosureTypes.html#WEAK"><span class="hs-identifier hs-var">WEAK</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span>
</span><span id="line-271"></span><span>            </span><span class="annot"><span class="annottext">Closure -&gt; IO Closure
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">(Closure -&gt; IO Closure) -&gt; Closure -&gt; IO Closure
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">WeakClosure :: forall b. StgInfoTable -&gt; b -&gt; b -&gt; b -&gt; b -&gt; b -&gt; GenClosure b
</span><a href="GHC.Exts.Heap.Closures.html#WeakClosure"><span class="hs-identifier hs-type">WeakClosure</span></a></span><span>
</span><span id="line-272"></span><span>                </span><span class="hs-special">{</span><span> </span><span class="annot"><span class="annottext">info :: StgInfoTable
</span><a href="GHC.Exts.Heap.Closures.html#info"><span class="hs-identifier hs-var">info</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">StgInfoTable
</span><a href="#local-6989586621679058990"><span class="hs-identifier hs-var">itbl</span></a></span><span>
</span><span id="line-273"></span><span>                </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">cfinalizers :: Box
</span><a href="GHC.Exts.Heap.Closures.html#cfinalizers"><span class="hs-identifier hs-var">cfinalizers</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[Box]
</span><a href="#local-6989586621679058991"><span class="hs-identifier hs-var">pts</span></a></span><span> </span><span class="annot"><span class="annottext">[Box] -&gt; Int -&gt; Box
forall a. [a] -&gt; Int -&gt; a
</span><a href="../../base/src/GHC.List.html#%21%21"><span class="hs-operator hs-var">!!</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span>
</span><span id="line-274"></span><span>                </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">key :: Box
</span><a href="GHC.Exts.Heap.Closures.html#key"><span class="hs-identifier hs-var">key</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[Box]
</span><a href="#local-6989586621679058991"><span class="hs-identifier hs-var">pts</span></a></span><span> </span><span class="annot"><span class="annottext">[Box] -&gt; Int -&gt; Box
forall a. [a] -&gt; Int -&gt; a
</span><a href="../../base/src/GHC.List.html#%21%21"><span class="hs-operator hs-var">!!</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span>
</span><span id="line-275"></span><span>                </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">value :: Box
</span><a href="GHC.Exts.Heap.Closures.html#value"><span class="hs-identifier hs-var">value</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[Box]
</span><a href="#local-6989586621679058991"><span class="hs-identifier hs-var">pts</span></a></span><span> </span><span class="annot"><span class="annottext">[Box] -&gt; Int -&gt; Box
forall a. [a] -&gt; Int -&gt; a
</span><a href="../../base/src/GHC.List.html#%21%21"><span class="hs-operator hs-var">!!</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">2</span></span><span>
</span><span id="line-276"></span><span>                </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">finalizer :: Box
</span><a href="GHC.Exts.Heap.Closures.html#finalizer"><span class="hs-identifier hs-var">finalizer</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[Box]
</span><a href="#local-6989586621679058991"><span class="hs-identifier hs-var">pts</span></a></span><span> </span><span class="annot"><span class="annottext">[Box] -&gt; Int -&gt; Box
forall a. [a] -&gt; Int -&gt; a
</span><a href="../../base/src/GHC.List.html#%21%21"><span class="hs-operator hs-var">!!</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">3</span></span><span>
</span><span id="line-277"></span><span>                </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">link :: Box
</span><a href="GHC.Exts.Heap.Closures.html#link"><span class="hs-identifier hs-var">link</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[Box]
</span><a href="#local-6989586621679058991"><span class="hs-identifier hs-var">pts</span></a></span><span> </span><span class="annot"><span class="annottext">[Box] -&gt; Int -&gt; Box
forall a. [a] -&gt; Int -&gt; a
</span><a href="../../base/src/GHC.List.html#%21%21"><span class="hs-operator hs-var">!!</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">4</span></span><span>
</span><span id="line-278"></span><span>                </span><span class="hs-special">}</span><span>
</span><span id="line-279"></span><span>
</span><span id="line-280"></span><span>        </span><span class="annot"><span class="annottext">ClosureType
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">-&gt;</span><span>
</span><span id="line-281"></span><span>            </span><span class="annot"><span class="annottext">Closure -&gt; IO Closure
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">(Closure -&gt; IO Closure) -&gt; Closure -&gt; IO Closure
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">StgInfoTable -&gt; Closure
forall b. StgInfoTable -&gt; GenClosure b
</span><a href="GHC.Exts.Heap.Closures.html#UnsupportedClosure"><span class="hs-identifier hs-var">UnsupportedClosure</span></a></span><span> </span><span class="annot"><span class="annottext">StgInfoTable
</span><a href="#local-6989586621679058990"><span class="hs-identifier hs-var">itbl</span></a></span><span>
</span><span id="line-282"></span><span>
</span><span id="line-283"></span><span class="hs-comment">-- | Like 'getClosureData', but taking a 'Box', so it is easier to work with.</span><span>
</span><span id="line-284"></span><span class="annot"><a href="GHC.Exts.Heap.html#getBoxedClosureData"><span class="hs-identifier hs-type">getBoxedClosureData</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Exts.Heap.Closures.html#Box"><span class="hs-identifier hs-type">Box</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#IO"><span class="hs-identifier hs-type">IO</span></a></span><span> </span><span class="annot"><a href="GHC.Exts.Heap.Closures.html#Closure"><span class="hs-identifier hs-type">Closure</span></a></span><span>
</span><span id="line-285"></span><span id="getBoxedClosureData"><span class="annot"><span class="annottext">getBoxedClosureData :: Box -&gt; IO Closure
</span><a href="GHC.Exts.Heap.html#getBoxedClosureData"><span class="hs-identifier hs-var hs-var">getBoxedClosureData</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Exts.Heap.Closures.html#Box"><span class="hs-identifier hs-type">Box</span></a></span><span> </span><span id="local-6989586621679058909"><span class="annot"><span class="annottext">Any
</span><a href="#local-6989586621679058909"><span class="hs-identifier hs-var">a</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Any -&gt; IO Closure
forall a. HasHeapRep a =&gt; a -&gt; IO Closure
</span><a href="GHC.Exts.Heap.html#getClosureData"><span class="hs-identifier hs-var">getClosureData</span></a></span><span> </span><span class="annot"><span class="annottext">Any
</span><a href="#local-6989586621679058909"><span class="hs-identifier hs-var">a</span></a></span><span>
</span><span id="line-286"></span></pre></body></html>